@adonis-agora/authkit-server 0.34.0

package/build/src/accounts/lucid_store/core.js

@@ -0,0 +1,306 @@
+import { randomBytes } from 'node:crypto';
+import { DateTime } from 'luxon';
+import { Scrypt } from '@adonisjs/core/hash/drivers/scrypt';
+import { hasColumn } from './status_profile.js';
+/** Prefixo do token de troca de e-mail (reaproveita a coluna emailVerificationToken). */
+const EMAIL_CHANGE_PREFIX = 'ec:';
+/** Prefixo do magic link (reaproveita as colunas de reset de senha). */
+const MAGIC_LINK_PREFIX = 'ml:';
+/**
+ * Hasher usado SOMENTE para a verificação "dummy" anti-enumeração (mesma
+ * instância/parâmetros do mixin withAuthUser). Não toca em hashes reais.
+ */
+const dummyHasher = new Scrypt({});
+/**
+ * Hash dummy pré-computado de uma senha aleatória (descartada). É um scrypt
+ * REAL com os mesmos parâmetros de custo dos hashes de conta — verificar contra
+ * ele gasta ~o mesmo tempo de CPU que verificar um hash legítimo.
+ *
+ * Promise resolvida UMA vez no boot do módulo; o caminho sem-row aguarda-a e
+ * roda `dummyHasher.verify` para igualar o timing do caminho com-row, mitigando
+ * account enumeration por timing no login (OWASP).
+ */
+const dummyHashPromise = dummyHasher.make(randomBytes(32).toString('hex'));
+/**
+ * Núcleo SEMPRE presente do {@link CoreAccountStore} sobre um model Lucid:
+ * identidade, cadastro, reset de senha, verificação de e-mail, administração
+ * (listagem paginada + roles globais) e o self-service de segurança
+ * ({@link AccountSecurityCapability}: trocar senha/e-mail).
+ */
+export function buildCore(ctx) {
+    const { Model, toAccount } = ctx;
+    return {
+        async findById(id) {
+            const row = await Model.find(id);
+            return row ? toAccount(row) : null;
+        },
+        async findByEmail(email) {
+            const row = await Model.query().where('email', email).first();
+            return row ? toAccount(row) : null;
+        },
+        async verifyCredentials(email, password) {
+            const row = await Model.query().where('email', email).first();
+            if (!row) {
+                // Anti-enumeração por timing: e-mail inexistente roda uma verificação
+                // scrypt DUMMY (mesmo custo do caminho real) e descarta o resultado, de
+                // modo que com-row e sem-row gastem ~o mesmo tempo de CPU. Best-effort:
+                // qualquer erro aqui NÃO altera o retorno (segue null).
+                try {
+                    const dummyHash = await dummyHashPromise;
+                    await ctx.passwords.verify(dummyHash, password, {
+                        nativeVerify: (hashed, plain) => dummyHasher.verify(hashed, plain),
+                        needsRehash: () => false,
+                    });
+                }
+                catch {
+                    // ignora — o objetivo é só gastar o tempo equivalente.
+                }
+                return null;
+            }
+            const result = await ctx.passwords.verify(row.password, password, {
+                nativeVerify: (_hashed, plain) => row.verifyPassword(plain),
+                needsRehash: () => row.passwordNeedsRehash(),
+            });
+            if (!result.ok)
+                return null;
+            // Lazy rehash transparente (padrão Auth0/Clerk): senha confere mas o hash
+            // está em formato legado OU com parâmetros desatualizados → re-hasheia com o
+            // hasher atual e persiste. Best-effort: uma falha no rehash NÃO falha o login.
+            if (result.rehash) {
+                try {
+                    row.password = password; // o @beforeSave do mixin re-hasheia
+                    await row.save();
+                    await ctx.audit?.record({ type: 'password.rehashed', accountId: row.id });
+                }
+                catch {
+                    // ignora — o usuário já está autenticado; o rehash tentará de novo no próximo login.
+                }
+            }
+            return toAccount(row);
+        },
+        async create(input) {
+            // Aplica a política de senha (comprimento/complexidade + vazamento) à senha
+            // nova. Lança PasswordPolicyError quando viola — o controller traduz a chave.
+            await ctx.passwords.assertAcceptable(input.password);
+            // Aplica o pepper antes do hash (o @beforeSave do mixin hasheia o que receber).
+            const pepperedPassword = ctx.passwords.applyCurrentPepper(input.password);
+            const now = DateTime.now();
+            const row = await Model.create({
+                email: input.email,
+                password: pepperedPassword,
+                fullName: input.fullName ?? null,
+                globalRoles: input.globalRoles ?? [],
+                emailVerifiedAt: input.emailVerified ? now : null,
+                // Registra quando a senha foi definida (se a coluna existe).
+                ...(hasColumn(Model, 'passwordChangedAt') ? { passwordChangedAt: now } : {}),
+            });
+            return toAccount(row);
+        },
+        async importAccount(input) {
+            // Skip se o e-mail já existe (idempotência do import).
+            const existing = await Model.query().where('email', input.email).first();
+            if (existing)
+                return null;
+            // Cria com uma senha aleatória (que o @beforeSave hasheia) só para satisfazer
+            // a coluna NOT NULL; em seguida sobrescreve com o hash de ORIGEM via query
+            // builder (bypassa o @beforeSave, então o hash entra COMO ESTÁ — o lazy rehash
+            // no 1º login migra para o hasher atual). NÃO aplica a política de senha.
+            const row = await Model.create({
+                email: input.email,
+                password: randomBytes(24).toString('hex'),
+                fullName: input.fullName ?? null,
+                globalRoles: input.globalRoles ?? [],
+                emailVerifiedAt: input.emailVerified ? DateTime.now() : null,
+            });
+            if (input.passwordHash) {
+                await Model.query().where('id', row.id).update({ password: input.passwordHash });
+                row.password = input.passwordHash;
+                // Limpa o dirty para que um save futuro não re-hasheie este hash de origem.
+                row.$attributes.password = input.passwordHash;
+            }
+            return toAccount(row);
+        },
+        async issuePasswordResetToken(email) {
+            const row = await Model.query().where('email', email).first();
+            if (!row)
+                return null;
+            const token = randomBytes(32).toString('hex');
+            row.passwordResetToken = token;
+            row.passwordResetExpiresAt = DateTime.now().plus({ hours: 1 });
+            await row.save();
+            return { token, account: toAccount(row) };
+        },
+        async consumePasswordResetToken(token, newPassword) {
+            // Magic links (`ml:`) NÃO são tokens de reset de senha — só o fluxo de
+            // consumeMagicLinkToken pode consumi-los (não trocam senha).
+            if (token.startsWith(MAGIC_LINK_PREFIX))
+                return false;
+            const row = await Model.query().where('passwordResetToken', token).first();
+            if (!row)
+                return false;
+            if (!row.passwordResetExpiresAt || row.passwordResetExpiresAt < DateTime.now())
+                return false;
+            // Política de senha aplicada também no reset (lança PasswordPolicyError).
+            await ctx.passwords.assertAcceptable(newPassword);
+            // Aplica o pepper antes do hash.
+            row.password = ctx.passwords.applyCurrentPepper(newPassword);
+            row.passwordResetToken = null;
+            row.passwordResetExpiresAt = null;
+            // Atualiza o timestamp da última troca (se a coluna existe).
+            if (hasColumn(Model, 'passwordChangedAt')) {
+                row.passwordChangedAt = DateTime.now();
+            }
+            await row.save();
+            return true;
+        },
+        // ----- Magic link (login passwordless) -----
+        async issueMagicLinkToken(email) {
+            const row = await Model.query().where('email', email).first();
+            if (!row)
+                return null;
+            // Token `ml:<random>` nas colunas de reset (sem migração); o prefixo o
+            // distingue de um token de reset de senha. Curta duração (15 min).
+            const token = `${MAGIC_LINK_PREFIX}${randomBytes(32).toString('hex')}`;
+            row.passwordResetToken = token;
+            row.passwordResetExpiresAt = DateTime.now().plus({ minutes: 15 });
+            await row.save();
+            return { token, account: toAccount(row) };
+        },
+        async consumeMagicLinkToken(token) {
+            if (!token || !token.startsWith(MAGIC_LINK_PREFIX))
+                return null;
+            const row = await Model.query().where('passwordResetToken', token).first();
+            if (!row)
+                return null;
+            if (!row.passwordResetExpiresAt || row.passwordResetExpiresAt < DateTime.now())
+                return null;
+            // Single-use: limpa o token (NÃO altera a senha).
+            row.passwordResetToken = null;
+            row.passwordResetExpiresAt = null;
+            await row.save();
+            return toAccount(row);
+        },
+        async issueEmailVerificationToken(email) {
+            const row = await Model.query().where('email', email).first();
+            if (!row)
+                return null;
+            const token = randomBytes(32).toString('hex');
+            row.emailVerificationToken = token;
+            await row.save();
+            return { token, account: toAccount(row) };
+        },
+        async consumeEmailVerificationToken(token) {
+            if (!token)
+                return false;
+            // Tokens de troca de e-mail (`ec:`) NÃO são verificações de cadastro — só o
+            // fluxo de confirmEmailChange pode consumi-los.
+            if (token.startsWith(EMAIL_CHANGE_PREFIX))
+                return false;
+            const row = await Model.query().where('emailVerificationToken', token).first();
+            if (!row)
+                return false;
+            row.emailVerifiedAt = DateTime.now();
+            row.emailVerificationToken = null;
+            await row.save();
+            return true;
+        },
+        // ----- Administração (console admin) -----
+        async listAccounts(params) {
+            const page = Math.max(1, params.page ?? 1);
+            const limit = Math.max(1, params.limit ?? 20);
+            const search = params.search?.trim();
+            const base = () => {
+                const q = Model.query();
+                // Filtro por e-mail (substring, case-insensitive). `whereILike` cai no LIKE
+                // no sqlite (case-insensitive por default p/ ASCII), e em ILIKE no Postgres.
+                if (search)
+                    q.whereILike('email', `%${search}%`);
+                return q;
+            };
+            const countResult = await base().count('* as total');
+            // O shape do count varia por dialeto; lê de $extras.total (Lucid).
+            const total = Number(countResult[0]?.$extras?.total ?? 0);
+            const rows = await base()
+                .orderBy('email', 'asc')
+                .offset((page - 1) * limit)
+                .limit(limit);
+            return { data: rows.map(toAccount), total };
+        },
+        async setGlobalRoles(accountId, roles) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return;
+            // A coluna `globalRoles` é serializada como JSON pelo mixin withAuthUser.
+            row.globalRoles = roles;
+            await row.save();
+        },
+        // ----- Self-service de segurança (console de conta) -----
+        async changePassword(accountId, newPassword) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            // Política de senha aplicada na troca (lança PasswordPolicyError).
+            await ctx.passwords.assertAcceptable(newPassword);
+            // O hash acontece no @beforeSave do mixin withAuthUser ao detectar $dirty.password.
+            // Aplica o pepper antes do hash.
+            const pepperedNew = ctx.passwords.applyCurrentPepper(newPassword);
+            row.password = pepperedNew;
+            // Atualiza o timestamp da última troca (se a coluna existe).
+            if (hasColumn(Model, 'passwordChangedAt')) {
+                row.passwordChangedAt = DateTime.now();
+            }
+            await row.save();
+            return true;
+        },
+        async requestEmailChange(accountId, newEmail) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return null;
+            // Não permite tomar um e-mail já usado por OUTRA conta.
+            const taken = await Model.query().where('email', newEmail).first();
+            if (taken && taken.id !== row.id)
+                return null;
+            // Token = `ec:<base64url(newEmail)>:<random>`. Reaproveita a coluna
+            // emailVerificationToken (sem migração nova); o prefixo `ec:` distingue do
+            // token de verificação de cadastro. O e-mail viaja codificado no próprio
+            // token, então não precisamos de coluna extra para o "pending email".
+            const encodedEmail = Buffer.from(newEmail, 'utf8').toString('base64url');
+            const token = `${EMAIL_CHANGE_PREFIX}${encodedEmail}:${randomBytes(24).toString('hex')}`;
+            row.emailVerificationToken = token;
+            await row.save();
+            return { token, account: toAccount(row), newEmail };
+        },
+        async confirmEmailChange(token) {
+            if (!token || !token.startsWith(EMAIL_CHANGE_PREFIX))
+                return { ok: false };
+            const parts = token.split(':');
+            // Forma esperada: ['ec', '<b64email>', '<random>']
+            if (parts.length !== 3)
+                return { ok: false };
+            let newEmail;
+            try {
+                newEmail = Buffer.from(parts[1], 'base64url').toString('utf8');
+            }
+            catch {
+                return { ok: false };
+            }
+            if (!newEmail)
+                return { ok: false };
+            const row = await Model.query().where('emailVerificationToken', token).first();
+            if (!row)
+                return { ok: false };
+            // Defesa contra corrida: o e-mail pode ter sido tomado entre o pedido e a
+            // confirmação por outra conta.
+            const taken = await Model.query().where('email', newEmail).first();
+            if (taken && taken.id !== row.id)
+                return { ok: false };
+            // Captura o e-mail antigo ANTES de sobrescrever (para notificações de segurança).
+            const oldEmail = row.email;
+            row.email = newEmail;
+            row.emailVerifiedAt = DateTime.now();
+            row.emailVerificationToken = null;
+            await row.save();
+            return { ok: true, account: toAccount(row), oldEmail, newEmail };
+        },
+    };
+}

package/build/src/accounts/lucid_store/mfa.d.ts

@@ -0,0 +1,15 @@
+import type { MfaCapability } from '../account_store.js';
+import { type LucidStoreContext } from './shared.js';
+/**
+ * Capacidade de MFA / TOTP — LIB-OWNED.
+ *
+ * O estado de MFA (`totp_secret`, `mfa_enabled_at`, `recovery_codes`,
+ * `last_totp_step`) vive numa tabela PRÓPRIA auto-gerida `auth_mfa` (criada pelo
+ * {@link ensureAuthkitSchema}), keyed por `account_id`. O host NÃO precisa migrar
+ * nada — `withMfa()` continua componível no model mas não declara mais colunas.
+ *
+ * Acesso ao banco via a CONEXÃO do próprio model (`Model.query().client`), a mesma
+ * usada pelo restante do store. O `email` (para o keyuri/QR) continua vindo do
+ * model principal — só o ESTADO de MFA migrou para `auth_mfa`.
+ */
+export declare function buildMfa(ctx: LucidStoreContext): MfaCapability;

package/build/src/accounts/lucid_store/mfa.js

@@ -0,0 +1,108 @@
+import { authenticator } from 'otplib';
+import { generateRecoveryCode, hashesEqual, sha256, buildMfaStateRepo, } from './shared.js';
+/**
+ * Capacidade de MFA / TOTP — LIB-OWNED.
+ *
+ * O estado de MFA (`totp_secret`, `mfa_enabled_at`, `recovery_codes`,
+ * `last_totp_step`) vive numa tabela PRÓPRIA auto-gerida `auth_mfa` (criada pelo
+ * {@link ensureAuthkitSchema}), keyed por `account_id`. O host NÃO precisa migrar
+ * nada — `withMfa()` continua componível no model mas não declara mais colunas.
+ *
+ * Acesso ao banco via a CONEXÃO do próprio model (`Model.query().client`), a mesma
+ * usada pelo restante do store. O `email` (para o keyuri/QR) continua vindo do
+ * model principal — só o ESTADO de MFA migrou para `auth_mfa`.
+ */
+export function buildMfa(ctx) {
+    const { Model, mfaIssuer, recoveryCodeCount, sealSecret, openSecret } = ctx;
+    const repo = buildMfaStateRepo(Model);
+    return {
+        async getMfaState(accountId) {
+            const state = await repo.read(accountId);
+            // `enabledAt` (epoch ms) habilita o trusted-device check: um cookie de
+            // confiança emitido ANTES deste instante é inválido (re-enrolar revoga).
+            return { enabled: !!state?.mfaEnabledAt, enabledAt: state?.mfaEnabledAt ?? null };
+        },
+        async startTotpEnrollment(accountId) {
+            // O email/QR vem do model principal; só o ESTADO de MFA vive em auth_mfa.
+            const row = await Model.find(accountId);
+            if (!row)
+                return null;
+            const secret = authenticator.generateSecret();
+            // Segredo PENDENTE: armazenado (encriptado em repouso) mas mfaEnabledAt continua null.
+            // Re-enrollment: zera o anti-replay para o NOVO segredo (o histórico de steps
+            // do segredo antigo não se aplica ao novo) e limpa recovery codes pendentes.
+            await repo.upsert(accountId, {
+                totpSecret: sealSecret(secret),
+                mfaEnabledAt: null,
+                recoveryCodes: null,
+                lastTotpStep: null,
+            });
+            const otpauthUri = authenticator.keyuri(row.email, mfaIssuer, secret);
+            return { secret, otpauthUri };
+        },
+        async confirmTotpEnrollment(accountId, code) {
+            const state = await repo.read(accountId);
+            if (!state || !state.totpSecret)
+                return { ok: false };
+            const secret = openSecret(state.totpSecret);
+            if (!secret)
+                return { ok: false };
+            // Só confirma a partir de um segredo pendente (não re-confirma um já ativo).
+            const valid = authenticator.verify({ token: String(code ?? ''), secret });
+            if (!valid)
+                return { ok: false };
+            const codes = Array.from({ length: recoveryCodeCount }, () => generateRecoveryCode());
+            await repo.upsert(accountId, {
+                mfaEnabledAt: Date.now(),
+                recoveryCodes: codes.map(sha256),
+            });
+            return { ok: true, recoveryCodes: codes };
+        },
+        async verifyTotp(accountId, code) {
+            const state = await repo.read(accountId);
+            if (!state || !state.mfaEnabledAt || !state.totpSecret)
+                return false;
+            const secret = openSecret(state.totpSecret);
+            if (!secret)
+                return false;
+            const token = String(code ?? '');
+            // M3 (anti-replay): `checkDelta` retorna o offset (delta) da janela onde o
+            // token bate, ou null se inválido. Convertemos o delta no índice ABSOLUTO
+            // da janela (`step`) usando o epoch/period correntes do otplib:
+            //   stepAtual = floor(epochSegundos / period)
+            //   stepDoToken = stepAtual + delta
+            const delta = authenticator.checkDelta(token, secret);
+            if (delta === null)
+                return false;
+            const opts = authenticator.allOptions();
+            // `epoch` vem em ms; `step` (period) em segundos. Default do otplib: epoch=now, step=30.
+            const period = opts.step || 30;
+            const currentStep = Math.floor(opts.epoch / 1000 / period);
+            const tokenStep = currentStep + delta;
+            // Rejeita replay: se este step já foi aceito (ou um posterior), nega. Isso
+            // impede reusar o MESMO código dentro da janela de validade (~30s) e também
+            // qualquer código de um step já consumido.
+            const last = typeof state.lastTotpStep === 'number' ? state.lastTotpStep : null;
+            if (last !== null && tokenStep <= last)
+                return false;
+            // Sucesso: persiste o step aceito para barrar o próximo replay.
+            await repo.upsert(accountId, { lastTotpStep: tokenStep });
+            return true;
+        },
+        async consumeRecoveryCode(accountId, code) {
+            const state = await repo.read(accountId);
+            if (!state || !state.mfaEnabledAt || !Array.isArray(state.recoveryCodes))
+                return false;
+            const target = sha256(String(code ?? '').trim());
+            const remaining = state.recoveryCodes.filter((h) => !hashesEqual(h, target));
+            if (remaining.length === state.recoveryCodes.length)
+                return false; // nada casou
+            await repo.upsert(accountId, { recoveryCodes: remaining });
+            return true;
+        },
+        async disableMfa(accountId) {
+            // Limpa todo o estado de MFA. Inclui o anti-replay: um futuro re-enroll começa do zero.
+            await repo.clear(accountId);
+        },
+    };
+}

package/build/src/accounts/lucid_store/organizations.d.ts

@@ -0,0 +1,13 @@
+import type { OrganizationsCapability } from '../account_store.js';
+/**
+ * Contexto mínimo para o builder de organizations. Recebe os três models direto
+ * (já construídos pelo lucidAccountStore após o hasTable probing).
+ */
+export interface OrgStoreContext {
+    OrgModel: any;
+    MemberModel: any;
+    InvitationModel: any;
+    /** Mapa accountId → email, para validar aceitação de convite. */
+    findAccountEmail: (accountId: string) => Promise<string | null>;
+}
+export declare function buildOrganizations(ctx: OrgStoreContext): OrganizationsCapability;