Merge pull request #83 from melgarafael/fix/issues-64-66

Teto de tentativas na superfície de auth + invariante de versões do AGENTS.md. O e2e pegou dois defeitos do meu desenho no caminho (contagem em sucesso, e latência do Redis morto).

Author: melgarafael

.gitignore

@@ -1,5 +1,9 @@
 # Dependencies
 node_modules/
+# Sem a barra tambem: `node_modules/` casa so com diretorio, e um SYMLINK
+# chamado node_modules (worktree apontando para a instalacao principal) passa
+# batido e vai parar no commit. Aconteceu no PR #83.
+node_modules
 .pnp
 .pnp.js
 

app/actions/auth/requestPasswordReset.ts

@@ -5,6 +5,7 @@ import { headers } from "next/headers";
 import { createClient } from "@/lib/supabase/server";
 import { forgotPasswordSchema, type ForgotPasswordInput } from "@/lib/auth/schemas";
 import { audit, hashEmail } from "@/lib/audit";
+import { authRateLimited, AUTH_LIMITS } from "@/lib/auth/rate-limit";
 import { env } from "@/lib/env";
 
 export type RequestPasswordResetResult =
@@ -38,6 +39,12 @@ export async function requestPasswordReset(
   const ip = hdrs.get("x-forwarded-for")?.split(",")[0]?.trim() ?? null;
   const userAgent = hdrs.get("user-agent") ?? null;
 
+  // Sem teto, este endpoint é uma metralhadora de e-mail contra terceiros e um
+  // oráculo de enumeração de conta. Issue #64.
+  if (await authRateLimited("reset", parsed.data.email, AUTH_LIMITS.reset)) {
+    return { ok: false, error: "rate_limited" };
+  }
+
   const supabase = await createClient();
   const { error } = await supabase.auth.resetPasswordForEmail(parsed.data.email, {
     redirectTo: `${origin}/auth/confirm`,

app/actions/auth/signInWithPassword.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Issue #64 — o teto está LIGADO no login, não só disponível numa lib.
+ *
+ * O helper tem teste próprio (lib/auth/rate-limit.test.ts); este aqui prova a
+ * fiação: a action recusa a 6ª tentativa contra a MESMA conta dentro da janela,
+ * antes de falar com o GoTrue. Sem a chamada em signInWithPassword.ts, as seis
+ * tentativas chegariam ao provedor e o teste fica vermelho.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { headers } from "next/headers";
+import { createClient } from "@/lib/supabase/server";
+
+vi.mock("next/headers", () => ({ headers: vi.fn() }));
+vi.mock("@/lib/supabase/server", () => ({ createClient: vi.fn() }));
+vi.mock("@/lib/audit", async (orig) => ({
+  ...(await orig<Record<string, unknown>>()),
+  audit: vi.fn(async () => undefined),
+}));
+vi.mock("next/navigation", () => ({ redirect: vi.fn() }));
+
+const signIn = vi.fn(async () => ({
+  data: { user: null, session: null },
+  error: { message: "Invalid login credentials", status: 400 },
+}));
+
+describe("signInWithPassword — teto de tentativas", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    signIn.mockClear();
+    vi.mocked(headers).mockResolvedValue({
+      get: (k: string) => (k === "x-forwarded-for" ? "203.0.113.77" : null),
+    } as never);
+    signIn.mockResolvedValue({
+      data: { user: null, session: null },
+      error: { message: "Invalid login credentials", status: 400 },
+    } as never);
+    vi.mocked(createClient).mockResolvedValue({
+      auth: {
+        signInWithPassword: signIn,
+        mfa: { listFactors: vi.fn(async () => ({ data: { totp: [{ id: "f1" }] } })) },
+      },
+    } as never);
+  });
+
+  it("recusa a 6ª tentativa contra a mesma conta sem chamar o provedor", async () => {
+    const { signInWithPassword } = await import("./signInWithPassword");
+    const input = { email: "alvo@example.com", password: "senha-errada-123" };
+
+    const resultados = [];
+    for (let i = 0; i < 6; i++) {
+      resultados.push(await signInWithPassword(input));
+    }
+
+    // AUTH_LIMITS.login.id = 5 → as 5 primeiras passam do teto e falham no
+    // provedor; a 6ª nem chega lá.
+    expect(resultados.slice(0, 5).map((r) => r.error)).toEqual(
+      Array(5).fill("invalid_credentials"),
+    );
+    expect(resultados[5]?.error).toBe("rate_limited");
+    expect(signIn).toHaveBeenCalledTimes(5);
+  });
+
+  it("acertar a senha não gasta o orçamento de bloqueio da conta", async () => {
+    const { signInWithPassword } = await import("./signInWithPassword");
+    const input = { email: "certo@example.com", password: "senha-certa-123" };
+
+    // Provedor aceita, e a conta tem MFA — o retorno é mfa_required, o que
+    // basta: o ponto é que o caminho de SUCESSO não incrementa o contador.
+    signIn.mockResolvedValue({
+      data: { user: { id: "u1" }, session: {} },
+      error: null,
+    } as never);
+
+    const resultados = [];
+    for (let i = 0; i < 10; i++) {
+      resultados.push(await signInWithPassword(input));
+    }
+
+    // Nenhuma das dez foi barrada: se o sucesso contasse, a 6ª seria.
+    expect(resultados.filter((r) => r?.error === "rate_limited")).toHaveLength(0);
+    expect(signIn).toHaveBeenCalledTimes(10);
+  });
+});

app/actions/auth/signInWithPassword.ts

@@ -6,6 +6,12 @@ import { redirect } from "next/navigation";
 import { createClient } from "@/lib/supabase/server";
 import { loginSchema, type LoginInput } from "@/lib/auth/schemas";
 import { audit, hashEmail } from "@/lib/audit";
+import {
+  authRateLimited,
+  contaBloqueadaPorFalhas,
+  registrarFalhaDeLogin,
+  AUTH_LIMITS,
+} from "@/lib/auth/rate-limit";
 
 export type SignInResult = {
   ok: false;
@@ -43,12 +49,31 @@ export async function signInWithPassword(
   const ip = hdrs.get("x-forwarded-for")?.split(",")[0]?.trim() ?? null;
   const userAgent = hdrs.get("user-agent") ?? null;
 
+  // Antes de falar com o GoTrue: sem isto, tentar senha era de graça e
+  // ilimitado (issue #64). Conta por IP e por conta — o ataque distribuído
+  // contra um e-mail só não aparece na contagem por IP.
+  if (
+    (await authRateLimited("login", null, AUTH_LIMITS.login)) ||
+    (await contaBloqueadaPorFalhas(parsed.data.email, AUTH_LIMITS.login))
+  ) {
+    await audit({
+      action: "auth.login_rate_limited",
+      metadata: { email_hash: hashEmail(parsed.data.email) },
+      requestId,
+      ip,
+      userAgent,
+    });
+    return { ok: false, error: "rate_limited" };
+  }
+
   const { data, error } = await supabase.auth.signInWithPassword({
     email: parsed.data.email,
     password: parsed.data.password,
   });
 
   if (error || !data.user) {
+    // Só senha errada gasta o orçamento da conta.
+    await registrarFalhaDeLogin(parsed.data.email, AUTH_LIMITS.login);
     await audit({
       action: "auth.login_failed",
       metadata: {

app/actions/auth/signUp.ts

@@ -5,6 +5,7 @@ import { headers } from "next/headers";
 import { createClient } from "@/lib/supabase/server";
 import { signupSchema, type SignupInput } from "@/lib/auth/schemas";
 import { audit, hashEmail } from "@/lib/audit";
+import { authRateLimited, AUTH_LIMITS } from "@/lib/auth/rate-limit";
 import { env } from "@/lib/env";
 
 export type SignUpResult =
@@ -40,6 +41,12 @@ export async function signUp(input: SignupInput): Promise<SignUpResult> {
   const ip = hdrs.get("x-forwarded-for")?.split(",")[0]?.trim() ?? null;
   const userAgent = hdrs.get("user-agent") ?? null;
 
+  // Criar conta é fluxo raro por pessoa: teto baixo por IP evita fábrica de
+  // organizações (cada signup provisiona tenant). Issue #64.
+  if (await authRateLimited("signup", null, AUTH_LIMITS.signup)) {
+    return { ok: false, error: "rate_limited" };
+  }
+
   const supabase = await createClient();
   const { data, error } = await supabase.auth.signUp({
     email: parsed.data.email,

app/team/accept-invite/[token]/page.tsx

@@ -11,6 +11,7 @@
 import Link from "next/link";
 
 import { verifyInviteToken } from "@/lib/auth/invite-token";
+import { authRateLimited, AUTH_LIMITS } from "@/lib/auth/rate-limit";
 import { createClient } from "@/lib/supabase/server";
 import { acceptInviteAction } from "@/app/actions/team/acceptInvite";
 
@@ -22,6 +23,22 @@ interface PageProps {
 
 export default async function AcceptInvitePage({ params }: PageProps) {
   const { token } = await params;
+
+  // O gargalo de enumeração é AQUI, não no aceite: a rota é pública e cada
+  // GET testa um token. Sem teto, varrer o espaço de tokens sai de graça
+  // (issue #64). Barrar antes de verificar mantém a resposta indistinguível
+  // entre token válido e inválido para quem está varrendo.
+  if (await authRateLimited("invite_accept", null, AUTH_LIMITS.invite_accept)) {
+    return (
+      <Shell>
+        <h1 className="text-xl font-semibold">Muitas tentativas</h1>
+        <p className="mt-2 text-sm text-muted-foreground">
+          Aguarde alguns minutos e abra o link do convite de novo.
+        </p>
+      </Shell>
+    );
+  }
+
   const payload = verifyInviteToken(token);
 
   if (!payload) {

lib/ai/dispatcher/rate-limit.ts

@@ -27,7 +27,13 @@ function getRedis(): Redis | null {
     }
     return null;
   }
-  _redis = new Redis({ url, token });
+  // `retry: false`: com Redis inalcançável (URL errada, rede caída), o default
+  // do SDK re-tenta com backoff e cada chamada passa a custar SEGUNDOS. Como
+  // já existe fallback em memória logo abaixo, retentar aqui só transfere a
+  // indisponibilidade do Redis para a latência do login. Falhe rápido e caia
+  // para a memória. Medido: com URL morta, duas chamadas somavam ~8s numa
+  // requisição de recuperação de senha, estourando o timeout da tela.
+  _redis = new Redis({ url, token, retry: false });
   return _redis;
 }
 
@@ -94,3 +100,29 @@ export async function checkRateLimit(
     window_sec: windowSec,
   };
 }
+
+/**
+ * Lê o contador SEM incrementar (issue #64).
+ *
+ * Existe porque bloqueio por tentativa-que-falhou precisa de duas operações
+ * distintas: *consultar* antes de chamar o provedor (senão o ataque nunca é
+ * barrado antes de acontecer) e *incrementar* só quando a tentativa falha
+ * (senão login bem-sucedido consome o orçamento e tranca quem acertou a senha).
+ */
+export async function peekRateLimit(bucket: string, windowSec: number): Promise<number> {
+  const windowStart = Math.floor(Date.now() / (windowSec * 1000));
+  const key = `${bucket}:${windowStart}`;
+
+  const redis = getRedis();
+  if (!redis) {
+    const existing = _memBuckets.get(key);
+    return !existing || existing.expiresAt <= Date.now() ? 0 : existing.count;
+  }
+  try {
+    const value = await redis.get<number | string>(key);
+    return value == null ? 0 : Number(value);
+  } catch {
+    const existing = _memBuckets.get(key);
+    return !existing || existing.expiresAt <= Date.now() ? 0 : existing.count;
+  }
+}

lib/audit/actions.ts

@@ -5,6 +5,8 @@
 export type AuditAction =
   | "auth.login_success"
   | "auth.login_failed"
+  /** Teto de tentativas barrou antes de chegar ao provedor (issue #64). */
+  | "auth.login_rate_limited"
   | "auth.logout"
   | "auth.mfa_enrolled"
   | "auth.mfa_success"

lib/auth/rate-limit.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Issue #64 — o teto existe e conta as duas coisas.
+ *
+ * Sem Upstash configurado o `checkRateLimit` cai para o contador em memória do
+ * processo, que é exatamente o que este teste quer exercitar: o caminho real,
+ * sem mock do limitador. O que se mocka é só o `headers()` do Next, para
+ * escolher o IP de cada tentativa.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { headers } from "next/headers";
+
+vi.mock("next/headers", () => ({ headers: vi.fn() }));
+
+function comIp(ip: string) {
+  vi.mocked(headers).mockResolvedValue({
+    get: (k: string) => (k === "x-forwarded-for" ? ip : null),
+  } as never);
+}
+
+describe("authRateLimited", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("barra ao estourar o teto por IP", async () => {
+    const { authRateLimited } = await import("./rate-limit");
+    comIp("203.0.113.10");
+    const limites = { ip: 3, windowSec: 300 };
+
+    const veredito: boolean[] = [];
+    for (let i = 0; i < 4; i++) {
+      veredito.push(await authRateLimited("teste_ip", null, limites));
+    }
+
+    expect(veredito).toEqual([false, false, false, true]);
+  });
+
+  it("barra por identificador mesmo com o IP mudando a cada tentativa", async () => {
+    const { authRateLimited } = await import("./rate-limit");
+    const limites = { ip: 100, id: 2, windowSec: 300 };
+    const alvo = "vitima@example.com";
+
+    const veredito: boolean[] = [];
+    for (let i = 0; i < 3; i++) {
+      comIp(`198.51.100.${i}`); // IP diferente a cada tentativa: o ataque distribuído
+      veredito.push(await authRateLimited("teste_id", alvo, limites));
+    }
+
+    // Se só houvesse contagem por IP, os três passariam.
+    expect(veredito).toEqual([false, false, true]);
+  });
+
+  it("conta identificadores diferentes em baldes separados", async () => {
+    const { authRateLimited } = await import("./rate-limit");
+    comIp("203.0.113.20");
+    const limites = { ip: 100, id: 1, windowSec: 300 };
+
+    expect(await authRateLimited("teste_sep", "a@example.com", limites)).toBe(false);
+    expect(await authRateLimited("teste_sep", "b@example.com", limites)).toBe(false);
+    expect(await authRateLimited("teste_sep", "a@example.com", limites)).toBe(true);
+  });
+
+  it("não põe o e-mail em claro na chave do contador", async () => {
+    const rl = await import("@/lib/ai/dispatcher/rate-limit");
+    const spy = vi.spyOn(rl, "checkRateLimit");
+    vi.resetModules();
+    const { authRateLimited } = await import("./rate-limit");
+    comIp("203.0.113.30");
+
+    await authRateLimited("teste_pii", "cliente@example.com", { ip: 10, id: 10, windowSec: 300 });
+
+    const chaves = spy.mock.calls.map((c) => c[0]).join(" ");
+    expect(chaves).not.toContain("cliente@example.com");
+    expect(chaves).not.toContain("203.0.113.30");
+  });
+});