@hed-hog/core 0.0.387 → 0.0.390

package/src/integration-profile/testers/storage.testers.ts

@@ -0,0 +1,226 @@
+import { HeadBucketCommand, S3Client } from '@aws-sdk/client-s3';
+import { BlobServiceClient, StorageSharedKeyCredential } from '@azure/storage-blob';
+import { Storage } from '@google-cloud/storage';
+import { access, constants } from 'node:fs/promises';
+import { assertHttpUrl, fail, pass, requireFields, str } from './http-probe';
+import { IntegrationTester, IntegrationTestOutcome } from './integration-tester.types';
+
+/**
+ * Testadores dos providers de storage.
+ *
+ * Todos usam uma operação de LEITURA (HeadBucket, getMetadata, getProperties): provam
+ * credencial, existência do bucket/container e permissão sem escrever nada na conta
+ * do cliente.
+ */
+
+/** Traduz o erro dos SDKs S3 em algo que o operador consiga agir. */
+async function headS3Bucket(
+  client: S3Client,
+  bucket: string,
+  label: string,
+  signal: AbortSignal,
+): Promise<IntegrationTestOutcome> {
+  try {
+    await client.send(new HeadBucketCommand({ Bucket: bucket }), {
+      abortSignal: signal,
+    });
+    return pass(label);
+  } catch (error) {
+    const err = error as {
+      name?: string;
+      message?: string;
+      $metadata?: { httpStatusCode?: number };
+    };
+    const status = err?.$metadata?.httpStatusCode;
+    const name = String(err?.name ?? '');
+
+    if (name === 'InvalidAccessKeyId' || status === 401) {
+      return fail('Invalid access key ID.');
+    }
+    if (name === 'SignatureDoesNotMatch') {
+      return fail('Invalid secret access key.');
+    }
+    if (name === 'NotFound' || status === 404) {
+      return fail(`Bucket "${bucket}" was not found.`);
+    }
+    if (name === 'Forbidden' || status === 403) {
+      return fail(
+        `These credentials have no permission to access the bucket "${bucket}".`,
+      );
+    }
+    if (name === 'PermanentRedirect' || status === 301) {
+      return fail(`Bucket "${bucket}" lives in another region.`);
+    }
+    return fail(String(err?.message ?? 'Could not reach the bucket.'));
+  } finally {
+    client.destroy();
+  }
+}
+
+const localTester: IntegrationTester = {
+  providerSlug: 'local',
+  test: async (config) => {
+    const basePath = str(config, 'base_path') || 'storage';
+    try {
+      // Só checa permissão — escrever um arquivo de teste sujaria o storage do cliente.
+      await access(basePath, constants.R_OK | constants.W_OK);
+      return pass(basePath);
+    } catch (error) {
+      const code = String((error as { code?: string })?.code ?? '');
+      if (code === 'ENOENT') {
+        return fail(`The directory "${basePath}" does not exist.`);
+      }
+      if (code === 'EACCES' || code === 'EPERM') {
+        return fail(`No read/write permission on the directory "${basePath}".`);
+      }
+      return fail(`Could not access the directory "${basePath}".`);
+    }
+  },
+};
+
+const s3Tester: IntegrationTester = {
+  providerSlug: 's3',
+  test: async (config, ctx) => {
+    const missing = requireFields(config, [
+      ['access_key_id', 'Access key ID'],
+      ['secret_access_key', 'Secret access key'],
+      ['bucket', 'Bucket'],
+    ]);
+    if (missing) return missing;
+
+    const region = str(config, 'region') || 'us-east-1';
+    const bucket = str(config, 'bucket');
+    const sessionToken = String(config.session_token ?? '').trim();
+
+    const client = new S3Client({
+      region,
+      credentials: {
+        accessKeyId: str(config, 'access_key_id'),
+        secretAccessKey: String(config.secret_access_key ?? ''),
+        ...(sessionToken ? { sessionToken } : {}),
+      },
+    });
+
+    return headS3Bucket(client, bucket, `${bucket} (${region})`, ctx.signal);
+  },
+};
+
+const s3CompatibleTester: IntegrationTester = {
+  providerSlug: 's3-compatible',
+  test: async (config, ctx) => {
+    const missing = requireFields(config, [
+      ['endpoint', 'Endpoint'],
+      ['access_key_id', 'Access key ID'],
+      ['secret_access_key', 'Secret access key'],
+      ['bucket', 'Bucket'],
+    ]);
+    if (missing) return missing;
+
+    const endpoint = assertHttpUrl(str(config, 'endpoint'), 'Endpoint');
+    const bucket = str(config, 'bucket');
+    const region = str(config, 'region') || 'us-east-1';
+
+    const client = new S3Client({
+      region,
+      endpoint: endpoint.origin,
+      // Provedores compatíveis (MinIO, Ceph) raramente resolvem bucket por subdomínio.
+      forcePathStyle: true,
+      credentials: {
+        accessKeyId: str(config, 'access_key_id'),
+        secretAccessKey: String(config.secret_access_key ?? ''),
+      },
+    });
+
+    return headS3Bucket(client, bucket, `${bucket} @ ${endpoint.host}`, ctx.signal);
+  },
+};
+
+const gcsTester: IntegrationTester = {
+  providerSlug: 'gcs',
+  test: async (config) => {
+    const missing = requireFields(config, [
+      ['key_file_json', 'Service account JSON'],
+      ['bucket', 'Bucket'],
+    ]);
+    if (missing) return missing;
+
+    let credentials: { project_id?: string; client_email?: string };
+    try {
+      credentials = JSON.parse(String(config.key_file_json ?? ''));
+    } catch {
+      return fail('The service account JSON is not valid JSON.');
+    }
+    if (!credentials?.client_email) {
+      return fail('The service account JSON has no "client_email".');
+    }
+
+    const bucket = str(config, 'bucket');
+    try {
+      const storage = new Storage({
+        projectId: credentials.project_id,
+        credentials: credentials as Record<string, string>,
+      });
+      const [metadata] = await storage.bucket(bucket).getMetadata();
+      return pass(`${bucket}${metadata?.location ? ` (${metadata.location})` : ''}`);
+    } catch (error) {
+      const err = error as { code?: number; message?: string };
+      if (err?.code === 404) return fail(`Bucket "${bucket}" was not found.`);
+      if (err?.code === 403) {
+        return fail(
+          `The service account has no permission to access the bucket "${bucket}".`,
+        );
+      }
+      if (err?.code === 401) return fail('The service account key was rejected.');
+      return fail(String(err?.message ?? 'Could not reach the bucket.'));
+    }
+  },
+};
+
+const azureBlobTester: IntegrationTester = {
+  providerSlug: 'azure-blob',
+  test: async (config) => {
+    const missing = requireFields(config, [
+      ['account', 'Storage account'],
+      ['key', 'Access key'],
+      ['container', 'Container'],
+    ]);
+    if (missing) return missing;
+
+    const account = str(config, 'account');
+    const container = str(config, 'container');
+
+    let credential: StorageSharedKeyCredential;
+    try {
+      credential = new StorageSharedKeyCredential(account, String(config.key ?? ''));
+    } catch {
+      // O SDK decodifica a chave em base64 na construção.
+      return fail('The access key is not a valid Azure storage key.');
+    }
+
+    try {
+      const service = new BlobServiceClient(
+        `https://${account}.blob.core.windows.net`,
+        credential,
+      );
+      await service.getContainerClient(container).getProperties();
+      return pass(`${account}/${container}`);
+    } catch (error) {
+      const err = error as { statusCode?: number; code?: string; message?: string };
+      if (err?.statusCode === 403 || err?.code === 'AuthenticationFailed') {
+        return fail('The storage account or access key was rejected.');
+      }
+      if (err?.statusCode === 404 || err?.code === 'ContainerNotFound') {
+        return fail(`Container "${container}" was not found.`);
+      }
+      return fail(String(err?.message ?? 'Could not reach the container.'));
+    }
+  },
+};
+
+export const STORAGE_TESTERS: IntegrationTester[] = [
+  localTester,
+  s3Tester,
+  s3CompatibleTester,
+  gcsTester,
+  azureBlobTester,
+];

package/src/integration-profile/testers/tester-coverage.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from '@jest/globals';
+import { INTEGRATION_SECRET_KEYS } from '../integration-profile.secrets';
+import { BUILTIN_INTEGRATION_TESTERS } from './index';
+
+/**
+ * TRAVA ANTI-DRIFT, no mesmo espírito de integration-profile.secrets.spec.ts.
+ *
+ * Um provider novo entra no catálogo por YAML e ganha campos no form do admin. Sem
+ * este teste, o botão "Testar conexão" simplesmente responderia "não disponível para
+ * este provedor" — uma falha silenciosa, que só aparece quando alguém tenta usar.
+ */
+
+/** Providers cujo tester vive em outra library (não pode ser embutido no core). */
+const EXTERNAL_PROVIDERS = new Set([
+  // Abrir o certificado A1 é código do domínio fiscal: o tester se registra pelo
+  // NfseNationalModule (libraries/fiscal).
+  'nfse-national',
+]);
+
+/** Providers legítimos sem nenhum campo secreto. */
+const PROVIDERS_WITHOUT_SECRETS = new Set([
+  // Storage no disco local: só um caminho, sem credencial.
+  'local',
+]);
+
+const registeredSlugs = new Set(
+  BUILTIN_INTEGRATION_TESTERS.map((tester) => tester.providerSlug),
+);
+
+describe('cobertura dos testers de conexão', () => {
+  it('todo provider com credenciais tem um tester (embutido ou de outra library)', () => {
+    const missing = Object.keys(INTEGRATION_SECRET_KEYS).filter(
+      (slug) => !registeredSlugs.has(slug) && !EXTERNAL_PROVIDERS.has(slug),
+    );
+
+    expect(missing).toEqual([]);
+  });
+
+  it('todo tester embutido corresponde a um provider conhecido', () => {
+    const unknown = [...registeredSlugs].filter(
+      (slug) =>
+        !(slug in INTEGRATION_SECRET_KEYS) && !PROVIDERS_WITHOUT_SECRETS.has(slug),
+    );
+
+    expect(unknown).toEqual([]);
+  });
+
+  it('não há dois testers para o mesmo provider', () => {
+    expect(registeredSlugs.size).toBe(BUILTIN_INTEGRATION_TESTERS.length);
+  });
+
+  it('todo tester expõe um providerSlug normalizado e uma função test', () => {
+    for (const tester of BUILTIN_INTEGRATION_TESTERS) {
+      expect(tester.providerSlug).toBe(tester.providerSlug.toLowerCase().trim());
+      expect(typeof tester.test).toBe('function');
+    }
+  });
+});

package/src/language/en.json

@@ -26,7 +26,8 @@
   },
   "forgot": {
     "rateLimit": "Too many requests. Please try again later.",
-    "userNotFound": "User not found."
+    "userNotFound": "User not found.",
+    "noPassword": "This account does not have a password set. Please sign in using your organization's login provider (e.g. Microsoft)."
   },
   "challenge": {
     "invalidOrExpired": "The provided code is invalid or has expired."
@@ -70,7 +71,8 @@
     "minLowercase": "Password must contain at least {minLowercase} lowercase letter(s).",
     "minUppercase": "Password must contain at least {minUppercase} uppercase letter(s).",
     "minNumbers": "Password must contain at least {minNumbers} number(s).",
-    "minSymbols": "Password must contain at least {minSymbols} special character(s)."
+    "minSymbols": "Password must contain at least {minSymbols} special character(s).",
+    "leaked": "This password appears in known data breaches. Please choose another one."
   },
   "createUser": {
     "nameRequired": "Name is required."

package/src/language/pt.json

@@ -26,7 +26,8 @@
   },
   "forgot": {
     "rateLimit": "Muitas solicitações. Por favor, tente novamente mais tarde.",
-    "userNotFound": "Usuário não encontrado."
+    "userNotFound": "Usuário não encontrado.",
+    "noPassword": "Esta conta não possui senha cadastrada. Faça login utilizando o provedor de acesso da sua organização (ex: Microsoft)."
   },
   "challenge": {
     "invalidOrExpired": "O código informado é inválido ou expirou."
@@ -70,7 +71,8 @@
     "minLowercase": "A senha deve conter pelo menos {minLowercase} letra(s) minúscula(s).",
     "minUppercase": "A senha deve conter pelo menos {minUppercase} letra(s) maiúscula(s).",
     "minNumbers": "A senha deve conter pelo menos {minNumbers} número(s).",
-    "minSymbols": "A senha deve conter pelo menos {minSymbols} caractere(s) especial(is)."
+    "minSymbols": "A senha deve conter pelo menos {minSymbols} caractere(s) especial(is).",
+    "leaked": "Esta senha aparece em vazamentos de dados conhecidos. Escolha outra."
   },
   "createUser": {
     "nameRequired": "Nome é obrigatório."

package/src/leaked-password/README.md

@@ -0,0 +1,83 @@
+# Senhas vazadas conhecidas
+
+Corpus de hashes SHA-1 de senhas que aparecem em vazamentos públicos, com duas
+leituras bem diferentes.
+
+## Por que bloom filter, e não uma consulta
+
+O cofre (`libraries/vaults`) é criptografado ponta a ponta: o servidor nunca vê
+uma senha guardada. Isso descarta o desenho óbvio ("o cliente pergunta se a
+senha X vazou") e também o modelo de k-anonimato do Pwned Passwords, em que o
+cliente manda o prefixo do hash — com corpus pequeno, um prefixo já identifica
+quase unicamente a senha.
+
+Então o servidor entrega o corpus inteiro como bloom filter e o navegador
+responde sozinho. Nada sobre a senha sai do cliente. O preço é a taxa de falso
+positivo do filtro (0,1%): uma senha pode ser apontada como vazada sem estar no
+corpus, nunca o contrário.
+
+| Caminho | Quem usa | Como |
+| --- | --- | --- |
+| `GET /leaked-password/filter` | cofre, medidor de força do formulário | baixa o filtro, testa local |
+| `LeakedPasswordService.isLeaked()` | validador de senha de **login** | consulta direta no banco |
+
+A consulta direta só vale onde a senha em claro já passa pelo servidor de
+qualquer forma (cadastro e troca de senha do sistema). Nunca use `isLeaked()`
+com senha de cofre.
+
+Tamanho do filtro: `-n·ln(p)/(ln2)²` bits. ~18 mil hashes ⇒ ~32KB; 1M ⇒ ~1,8MB.
+Ele é montado sob demanda e fica em memória enquanto a versão do corpus não muda
+(`count` + `created_at` mais recente), com `ETag` para o navegador revalidar de
+graça.
+
+## O que já vem semeado
+
+A migration `20260729180000_core_leaked_password` insere ~8,7 mil hashes gerados
+de [`seed/common-passwords.txt`](./seed/common-passwords.txt) — as senhas
+notórias de toda publicação anual de "senhas mais usadas", os equivalentes
+brasileiros, e a expansão delas nos padrões que dominam vazamento (sufixo
+numérico, ano, capitalização, leet).
+
+**Isto é uma base curada, não o top-N do Have I Been Pwned.** Cobre o reuso
+óbvio; cobertura real vem do import.
+
+O SHA-1 do seed vai calculado em hex na migration porque o `pgcrypto` está
+disponível mas não instalado no cluster, e `CREATE EXTENSION` exigiria
+superusuário em produção.
+
+Para regerar depois de mexer na lista base (criando uma migration nova — as
+existentes nunca são reescritas):
+
+```bash
+node libraries/core/src/leaked-password/seed/build-seed-sql.mjs --count   # confere o tamanho
+node libraries/core/src/leaked-password/seed/build-seed-sql.mjs > /tmp/seed.sql
+```
+
+## Ampliando o corpus
+
+```bash
+# lista base completa (~120 mil, a expansão que não caberia numa migration)
+node libraries/core/src/leaked-password/seed/build-seed-sql.mjs --full --plain > /tmp/base.txt
+pnpm import:leaked-passwords /tmp/base.txt
+
+# dump do Pwned Passwords, reduzido às N senhas mais frequentes
+sort -t: -k2 -rn pwnedpasswords.txt | head -1000000 > top1m.txt
+pnpm import:leaked-passwords top1m.txt
+
+pnpm import:leaked-passwords arquivo.txt --dry-run          # só relata
+pnpm import:leaked-passwords arquivo.txt --limit 50000      # para em N linhas lidas
+pnpm import:leaked-passwords arquivo.txt --min-occurrences 10
+```
+
+O import é idempotente (o unique em `hash` + `skipDuplicates` absorvem
+repetição), então reprocessar o mesmo arquivo não faz nada.
+
+**Dimensione antes:** o dump completo do Pwned Passwords são ~850M hashes
+(~40GB no Postgres) e não cabe no banco deste projeto. 1M hashes ⇒ ~80MB de
+tabela e índice.
+
+## Desligando
+
+A setting `password-block-leaked` (grupo de política de senha, padrão ligada)
+controla as duas pontas: desligada, o validador de login para de recusar e o
+cliente nem baixa o filtro.

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

@@ -0,0 +1,52 @@
+import { Role } from '@hed-hog/api';
+import { Controller, Get, Inject, Req, Res, forwardRef } from '@nestjs/common';
+import type { Request, Response } from 'express';
+import { LeakedPasswordService } from './leaked-password.service';
+
+/**
+ * Entrega o bloom filter do corpus de senhas vazadas para o cliente testar as
+ * senhas do cofre localmente.
+ *
+ * É o desenho que mantém a criptografia ponta a ponta: em vez de o navegador
+ * perguntar "esta senha vazou?" (revelando a senha, ou pelo menos um prefixo do
+ * hash dela), ele baixa o filtro inteiro uma vez e responde sozinho.
+ *
+ * Autenticado de propósito: o conteúdo é público em essência, mas são MBs por
+ * download, e o `If-None-Match` faz o navegador revalidar de graça.
+ */
+@Role()
+@Controller('leaked-password')
+export class LeakedPasswordController {
+  constructor(
+    @Inject(forwardRef(() => LeakedPasswordService))
+    private readonly leakedPasswordService: LeakedPasswordService,
+  ) {}
+
+  @Get('filter')
+  async filter(@Req() req: Request, @Res() res: Response): Promise<void> {
+    const filter = await this.leakedPasswordService.getFilter();
+
+    if (req.headers['if-none-match'] === filter.etag) {
+      res.status(304).end();
+      return;
+    }
+
+    res.set({
+      'Content-Type': 'application/octet-stream',
+      'Content-Length': String(filter.bytes.length),
+      ETag: filter.etag,
+      // `must-revalidate` com ETag: o navegador reusa o filtro sem baixar de novo,
+      // mas nunca serve corpus velho depois de um import.
+      'Cache-Control': 'private, max-age=0, must-revalidate',
+      'X-Leaked-Password-Count': String(filter.count),
+    });
+    res.end(filter.bytes);
+  }
+
+  /** Tamanho do corpus, para a tela de configuração mostrar o que está ativo. */
+  @Get('stats')
+  async stats() {
+    const version = await this.leakedPasswordService.getCorpusVersion();
+    return { count: version.count, lastUpdatedAt: version.lastCreatedAt };
+  }
+}

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

@@ -0,0 +1,18 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Global, Module } from '@nestjs/common';
+import { LeakedPasswordController } from './leaked-password.controller';
+import { LeakedPasswordService } from './leaked-password.service';
+
+/**
+ * `@Global()` porque o validador de política de senha alcança este serviço pelo
+ * service locator, de fora da árvore de injeção normal (mesmo caminho do
+ * SettingService).
+ */
+@Global()
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [LeakedPasswordController],
+  providers: [LeakedPasswordService],
+  exports: [LeakedPasswordService],
+})
+export class LeakedPasswordModule {}