@aventara/access 0.0.0-stage → 0.1.0-rc.0

package/dist/passwords/argon2id.hasher.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The argon2id parameter profiles, by name. Each keeps a 16-byte salt (RFC 9106
+ * section 3.1: "16 bytes is RECOMMENDED for password hashing") and a 32-byte tag (RFC 9106
+ * section 4: "256-bit tag size").
+ */
+export declare const ARGON2ID_PROFILES: {
+    readonly [P in AccessArgon2idProfile]: Argon2idCost;
+};
+/**
+ * The argon2id parameter profiles `createAccess` takes, by name: `"owasp-minimum"`
+ * (m=19456 KiB, t=2, p=1) or `"rfc9106-low-memory"` (m=65536 KiB, t=3, p=4).
+ */
+export type AccessArgon2idProfile = "owasp-minimum" | "rfc9106-low-memory";
+/** The profile `createAccess` hashes with when the app chose none. */
+export declare const DEFAULT_ARGON2ID_PROFILE: AccessArgon2idProfile;
+/** An argon2id cost: memory in KiB, passes (iterations) and lanes. */
+type Argon2idCost = {
+    readonly memory: number;
+    readonly passes: number;
+    readonly parallelism: number;
+};
+/** What the hasher takes from Node.js's `node:crypto`. */
+export type NodePasswordCrypto = {
+    readonly argon2: (algorithm: "argon2id", parameters: Argon2idCost & {
+        readonly message: string;
+        readonly nonce: Uint8Array;
+        readonly tagLength: number;
+    }, done: (error: Error | null, derivedKey: Uint8Array) => void) => void;
+    readonly randomBytes: (size: number) => Uint8Array;
+    readonly timingSafeEqual: (a: Uint8Array, b: Uint8Array) => boolean;
+};
+/** Better Auth's `emailAndPassword.password` hook: what the hasher answers as. */
+export type PasswordHook = {
+    readonly hash: (password: string) => Promise<string>;
+    readonly verify: (input: {
+        readonly hash: string;
+        readonly password: string;
+    }) => Promise<boolean>;
+};
+type Argon2idHasherOptions = {
+    readonly profile: AccessArgon2idProfile;
+    /** The longest password hashed or checked, in UTF-16 code units: Better Auth's `maxPasswordLength`. */
+    readonly maxPasswordLength: number;
+    readonly crypto: NodePasswordCrypto;
+    /** Better Auth's own scrypt `verifyPassword`, for hashes stored before argon2id. */
+    readonly verifyScrypt: (input: {
+        readonly hash: string;
+        readonly password: string;
+    }) => Promise<boolean>;
+    /**
+     * Whether Better Auth's scrypt hashes verify. Off: a scrypt hash fails the check.
+     * On: it verifies, and every hash and check also runs the other algorithm once,
+     * so a sign-in costs the same whichever hash an account holds, or none.
+     */
+    readonly legacyScrypt: boolean;
+    /** The error `hash` rejects a password over `maxPasswordLength` with. */
+    readonly tooLong: () => Error;
+    /** Where a refused stored hash or a failed computation is reported; never the hash or the password. */
+    readonly log: (level: "warn" | "error", message: string) => void;
+};
+/** Whether a stored hash is in Better Auth's scrypt format. */
+export declare const isLegacyScryptHash: (hash: string) => boolean;
+/**
+ * Better Auth's `emailAndPassword.password` hook, hashing with argon2id at
+ * `profile`. `verify` checks argon2id PHC strings at the parameters they name (up
+ * to {@link CEILING}), and, with `legacyScrypt`, Better Auth's scrypt hashes through
+ * Better Auth's own verify. It never throws: anything it cannot check is `false`.
+ *
+ * Every check costs one argon2id computation at the profile, whatever is stored
+ * (an argon2id hash, a malformed one, a scrypt hash with `legacyScrypt` off), as
+ * Better Auth's hash of a decoy costs for an unknown user; with `legacyScrypt` on,
+ * every hash and check also costs one scrypt. So the time a sign-in takes does not
+ * say what an account holds, but for one gap: a stored argon2id hash is checked at
+ * the parameters it names, so after a profile change a hash at the old profile
+ * costs the old profile's time until its account's next sign-in rehashes it at the
+ * profile ({@link needsRehash}). Passwords are NFKC-normalised first, as Better
+ * Auth's scrypt does, so one password typed on two keyboards hashes alike.
+ */
+export declare const argon2idHasher: (options: Argon2idHasherOptions) => PasswordHook;
+/** What decides whether a hash this hasher verified is rehashed: its profile, and `legacyScrypt`. */
+type RehashPolicy = {
+    readonly profile: AccessArgon2idProfile;
+    readonly legacyScrypt: boolean;
+};
+/** The rehash policy of a password hook's `verify`, `undefined` unless {@link argon2idHasher} built it. */
+export declare const rehashPolicyOf: (verify: unknown) => RehashPolicy | undefined;
+/**
+ * Whether a stored hash a password has just matched is rehashed at the policy's
+ * profile: a scrypt hash with `legacyScrypt` (without it, none verifies), or an
+ * argon2id PHC string whose parameters, salt or tag length are not the profile's,
+ * whether they cost less or more (the profile the app names is the one every hash
+ * is checked at, so a sign-in's time says nothing of when the account last signed
+ * in). A string Access cannot check (malformed, over the ceiling) never verifies,
+ * and is never rehashed.
+ */
+export declare const needsRehash: (stored: string, policy: RehashPolicy) => boolean;
+export {};

package/dist/passwords/argon2id.hasher.js

@@ -0,0 +1,256 @@
+// Password hashing with argon2id, on Node.js's own `crypto.argon2` (added in Node.js
+// 24.7.0; no native dependency). Better Auth hashes with scrypt; `createAccess` puts
+// this hasher in Better Auth's `emailAndPassword.password` hook unless the app set
+// that hook itself. It imports nothing: the caller hands it Node.js's primitives and
+// Better Auth's scrypt verify, so the Better Auth plugin entry can use it the same way.
+//
+// A hash is a PHC string, `$argon2id$v=19$m=<KiB>,t=<passes>,p=<lanes>$<salt>$<tag>`
+// (salt and tag in base64 without padding). `verify` reads the parameters from the
+// stored string, so a profile can change later and every older hash still verifies.
+// A stored value that is not a well-formed argon2id PHC string within the ceiling
+// below (or, with `legacyScrypt`, Better Auth's scrypt format) fails the check
+// (`false`); `verify` never throws.
+/**
+ * The argon2id parameter profiles, by name. Each keeps a 16-byte salt (RFC 9106
+ * section 3.1: "16 bytes is RECOMMENDED for password hashing") and a 32-byte tag (RFC 9106
+ * section 4: "256-bit tag size").
+ */
+export const ARGON2ID_PROFILES = {
+    /**
+     * OWASP Password Storage Cheat Sheet, Argon2id minimum configuration
+     * "m=19456 (19 MiB), t=2, p=1". The default.
+     */
+    "owasp-minimum": { memory: 19_456, passes: 2, parallelism: 1 },
+    /**
+     * RFC 9106 section 4, the SECOND RECOMMENDED option: "t=3 iterations, p=4 lanes,
+     * m=2^(16) (64 MiB of RAM)", for when 2 GiB per hash is not available.
+     */
+    "rfc9106-low-memory": { memory: 65_536, passes: 3, parallelism: 4 },
+};
+/** The profile `createAccess` hashes with when the app chose none. */
+export const DEFAULT_ARGON2ID_PROFILE = "owasp-minimum";
+const SALT_BYTES = 16;
+const TAG_BYTES = 32;
+/** Argon2 version 0x13, as PHC strings write it. */
+const VERSION = 19;
+/** The bounds on a stored hash's salt and tag, in bytes. */
+const STORED_BYTES = {
+    salt: { min: 8, max: 64 },
+    tag: { min: 16, max: 64 },
+};
+/**
+ * The most a stored hash may cost to check: each parameter at the largest any
+ * profile uses, and memory times passes too. A stored hash past it (a tampered row,
+ * or one written elsewhere) is refused without being computed, so it cannot make a
+ * sign-in allocate gigabytes or run for seconds. Derived from the profiles, so a
+ * profile added later raises it.
+ */
+const CEILING = (() => {
+    const ceiling = { memory: 0, passes: 0, parallelism: 0, work: 0 };
+    for (const profile of Object.keys(ARGON2ID_PROFILES)) {
+        const cost = ARGON2ID_PROFILES[profile];
+        ceiling.memory = Math.max(ceiling.memory, cost.memory);
+        ceiling.passes = Math.max(ceiling.passes, cost.passes);
+        ceiling.parallelism = Math.max(ceiling.parallelism, cost.parallelism);
+        ceiling.work = Math.max(ceiling.work, cost.memory * cost.passes);
+    }
+    return ceiling;
+})();
+/** Better Auth's scrypt format: a 16-byte hex salt, `:`, a 64-byte hex key. */
+const SCRYPT_HASH = /^[0-9a-f]{32}:[0-9a-f]{128}$/;
+/** Whether a stored hash is in Better Auth's scrypt format. */
+export const isLegacyScryptHash = (hash) => SCRYPT_HASH.test(hash);
+const DECIMAL = "(0|[1-9][0-9]{0,9})";
+const B64 = "([A-Za-z0-9+/]+)";
+const PHC_ARGON2ID = new RegExp(`^\\$argon2id\\$v=${DECIMAL}\\$m=${DECIMAL},t=${DECIMAL},p=${DECIMAL}\\$${B64}\\$${B64}$`);
+/** Bytes as unpadded standard base64, as PHC strings write them. */
+const toB64 = (bytes) => {
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary).replace(/=+$/, "");
+};
+/** Unpadded base64 as bytes; `undefined` unless it is the canonical spelling of them. */
+const fromB64 = (text) => {
+    if (text.length % 4 === 1) {
+        return undefined;
+    }
+    const binary = atob(text + "=".repeat((4 - (text.length % 4)) % 4));
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index++) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    // Unused low bits in the last character would let two strings name one value.
+    return toB64(bytes) === text ? bytes : undefined;
+};
+const within = (value, bounds) => value >= bounds.min && value <= bounds.max;
+/**
+ * A stored argon2id PHC string, read: its parameters and bytes, `"over-ceiling"`
+ * when it is well formed and costs more than {@link CEILING}, `undefined` when it is
+ * not an argon2id PHC string Access writes (another version, a parameter Argon2
+ * refuses, non-canonical base64, a salt or tag out of bounds).
+ */
+const readPhc = (stored) => {
+    const match = PHC_ARGON2ID.exec(stored);
+    if (match === null) {
+        return undefined;
+    }
+    // By index: destructuring the match costs the type checker a thousand instantiations.
+    const cost = {
+        memory: Number(match[2]),
+        passes: Number(match[3]),
+        parallelism: Number(match[4]),
+    };
+    const saltBytes = fromB64(match[5]);
+    const tagBytes = fromB64(match[6]);
+    if (Number(match[1]) !== VERSION ||
+        cost.passes < 1 ||
+        cost.parallelism < 1 ||
+        // Argon2 needs at least 8 blocks of 1 KiB per lane.
+        cost.memory < 8 * cost.parallelism ||
+        saltBytes === undefined ||
+        !within(saltBytes.length, STORED_BYTES.salt) ||
+        tagBytes === undefined ||
+        !within(tagBytes.length, STORED_BYTES.tag)) {
+        return undefined;
+    }
+    if (cost.memory > CEILING.memory ||
+        cost.passes > CEILING.passes ||
+        cost.parallelism > CEILING.parallelism ||
+        cost.memory * cost.passes > CEILING.work) {
+        return "over-ceiling";
+    }
+    return { ...cost, salt: saltBytes, tag: tagBytes };
+};
+/** A well-formed scrypt hash no password matches: the legacy check's cost, run as a decoy. */
+const DECOY_SCRYPT = `${"0".repeat(32)}:${"0".repeat(128)}`;
+/**
+ * Better Auth's `emailAndPassword.password` hook, hashing with argon2id at
+ * `profile`. `verify` checks argon2id PHC strings at the parameters they name (up
+ * to {@link CEILING}), and, with `legacyScrypt`, Better Auth's scrypt hashes through
+ * Better Auth's own verify. It never throws: anything it cannot check is `false`.
+ *
+ * Every check costs one argon2id computation at the profile, whatever is stored
+ * (an argon2id hash, a malformed one, a scrypt hash with `legacyScrypt` off), as
+ * Better Auth's hash of a decoy costs for an unknown user; with `legacyScrypt` on,
+ * every hash and check also costs one scrypt. So the time a sign-in takes does not
+ * say what an account holds, but for one gap: a stored argon2id hash is checked at
+ * the parameters it names, so after a profile change a hash at the old profile
+ * costs the old profile's time until its account's next sign-in rehashes it at the
+ * profile ({@link needsRehash}). Passwords are NFKC-normalised first, as Better
+ * Auth's scrypt does, so one password typed on two keyboards hashes alike.
+ */
+export const argon2idHasher = (options) => {
+    const { crypto, maxPasswordLength, verifyScrypt, legacyScrypt, tooLong, log, } = options;
+    const cost = ARGON2ID_PROFILES[options.profile];
+    const derive = (password, at, nonce, tagLength) => new Promise((resolve, reject) => {
+        crypto.argon2("argon2id", {
+            message: password.normalize("NFKC"),
+            nonce,
+            tagLength,
+            memory: at.memory,
+            passes: at.passes,
+            parallelism: at.parallelism,
+        }, (error, key) => (error === null ? resolve(key) : reject(error)));
+    });
+    /** A scrypt check, `false` on any failure. */
+    const scrypt = async (hash, password) => {
+        try {
+            return (await verifyScrypt({ hash, password })) === true;
+        }
+        catch {
+            log("error", "a scrypt password check failed; it counts as a mismatch.");
+            return false;
+        }
+    };
+    /** The argon2id check of a stored hash; a decoy at the profile when there is none to check. */
+    const argon2id = async (stored, password) => {
+        try {
+            const derived = await derive(password, stored ?? cost, stored?.salt ?? crypto.randomBytes(SALT_BYTES), stored?.tag.length ?? TAG_BYTES);
+            return (stored !== undefined && crypto.timingSafeEqual(derived, stored.tag));
+        }
+        catch {
+            log("error", "an argon2id password check failed; it counts as a mismatch.");
+            return false;
+        }
+    };
+    const hook = {
+        hash: async (password) => {
+            if (typeof password !== "string") {
+                throw new TypeError("A password is a string.");
+            }
+            if (password.length > maxPasswordLength) {
+                throw tooLong();
+            }
+            const salt = crypto.randomBytes(SALT_BYTES);
+            const tag = await derive(password, cost, salt, TAG_BYTES);
+            if (legacyScrypt) {
+                await scrypt(DECOY_SCRYPT, password);
+            }
+            return `$argon2id$v=${VERSION}$m=${cost.memory},t=${cost.passes},p=${cost.parallelism}$${toB64(salt)}$${toB64(tag)}`;
+        },
+        verify: async ({ hash, password }) => {
+            if (typeof hash !== "string" ||
+                typeof password !== "string" ||
+                password.length > maxPasswordLength) {
+                return false;
+            }
+            if (SCRYPT_HASH.test(hash)) {
+                if (!legacyScrypt) {
+                    log("warn", "a stored password hash is Better Auth's scrypt, and `passwords.legacyScrypt` is off: the sign-in is refused.");
+                    await argon2id(undefined, password);
+                    return false;
+                }
+                const matches = await scrypt(hash, password);
+                await argon2id(undefined, password);
+                return matches;
+            }
+            const stored = readPhc(hash);
+            if (stored === "over-ceiling") {
+                log("warn", `a stored argon2id password hash costs more than Access checks (m <= ${CEILING.memory}, t <= ${CEILING.passes}, p <= ${CEILING.parallelism}, m*t <= ${CEILING.work}): the sign-in is refused.`);
+            }
+            const matches = await argon2id(typeof stored === "object" ? stored : undefined, password);
+            if (legacyScrypt) {
+                await scrypt(DECOY_SCRYPT, password);
+            }
+            return matches;
+        },
+    };
+    REHASH_POLICIES.set(hook.verify, { profile: options.profile, legacyScrypt });
+    return hook;
+};
+/**
+ * Each hook {@link argon2idHasher} built, by its `verify`: Better Auth puts that
+ * same function in its context (`context.password.verify`), so a sign-in hook can
+ * tell Access's hasher, and its profile, from an app's own.
+ */
+const REHASH_POLICIES = new WeakMap();
+/** The rehash policy of a password hook's `verify`, `undefined` unless {@link argon2idHasher} built it. */
+export const rehashPolicyOf = (verify) => typeof verify === "function"
+    ? REHASH_POLICIES.get(verify)
+    : undefined;
+/**
+ * Whether a stored hash a password has just matched is rehashed at the policy's
+ * profile: a scrypt hash with `legacyScrypt` (without it, none verifies), or an
+ * argon2id PHC string whose parameters, salt or tag length are not the profile's,
+ * whether they cost less or more (the profile the app names is the one every hash
+ * is checked at, so a sign-in's time says nothing of when the account last signed
+ * in). A string Access cannot check (malformed, over the ceiling) never verifies,
+ * and is never rehashed.
+ */
+export const needsRehash = (stored, policy) => {
+    if (SCRYPT_HASH.test(stored)) {
+        return policy.legacyScrypt;
+    }
+    const read = readPhc(stored);
+    if (typeof read !== "object") {
+        return false;
+    }
+    const cost = ARGON2ID_PROFILES[policy.profile];
+    return (read.memory !== cost.memory ||
+        read.passes !== cost.passes ||
+        read.parallelism !== cost.parallelism ||
+        read.salt.length !== SALT_BYTES ||
+        read.tag.length !== TAG_BYTES);
+};

package/dist/passwords/node-rs-argon2.adapter.d.ts

@@ -0,0 +1,25 @@
+import type { NodePasswordCrypto } from "./argon2id.hasher.js";
+/** The exact `@node-rs/argon2` version Access is built and tested against. */
+export declare const NODE_RS_ARGON2_VERSION = "2.2.2";
+/** What Access takes from `@node-rs/argon2`: the raw tag of one argon2 computation. */
+export type NodeRsArgon2 = {
+    readonly hashRaw: (password: string, options: {
+        /** `2` is `Algorithm.Argon2id`. */
+        readonly algorithm: 2;
+        /** `1` is `Version.V0x13`, Argon2 version 19. */
+        readonly version: 1;
+        readonly memoryCost: number;
+        readonly timeCost: number;
+        readonly parallelism: number;
+        readonly outputLen: number;
+        readonly salt: Uint8Array;
+    }) => Promise<Uint8Array>;
+};
+/** `@node-rs/argon2`'s `hashRaw` as Node.js's `crypto.argon2("argon2id", …)`. */
+export declare const nodeRsArgon2: (module: NodeRsArgon2) => NodePasswordCrypto["argon2"];
+/**
+ * What hashing takes from Node.js: its `node:crypto` when it has `crypto.argon2`
+ * (Node.js 24.7.0 and later; `@node-rs/argon2` is then never loaded, installed or
+ * not), else the same with `@node-rs/argon2` behind `argon2`, else without `argon2`.
+ */
+export declare const passwordCryptoOf: (nodeCrypto: Partial<NodePasswordCrypto>, loadNodeRs: () => NodeRsArgon2 | undefined) => Partial<NodePasswordCrypto>;

package/dist/passwords/node-rs-argon2.adapter.js

@@ -0,0 +1,42 @@
+// The argon2id backend on Node.js 22, which has no `crypto.argon2`: `@node-rs/argon2`,
+// an exact optional peer, loaded only when Node.js's own is missing. Its `hashRaw`
+// is put behind Node.js's `crypto.argon2` signature, so the hasher runs the same code
+// on either: it writes the PHC string and compares the tags itself, and the two
+// backends compute the same RFC 9106 function, so a hash made on one verifies on the
+// other. It imports nothing: the package's Node.js module loader hands it over.
+/** The exact `@node-rs/argon2` version Access is built and tested against. */
+export const NODE_RS_ARGON2_VERSION = "2.2.2";
+/** `@node-rs/argon2`'s `hashRaw` as Node.js's `crypto.argon2("argon2id", …)`. */
+export const nodeRsArgon2 = (module) => (_algorithm, parameters, done) => {
+    module
+        .hashRaw(parameters.message, {
+        algorithm: 2,
+        version: 1,
+        memoryCost: parameters.memory,
+        timeCost: parameters.passes,
+        parallelism: parameters.parallelism,
+        outputLen: parameters.tagLength,
+        salt: parameters.nonce,
+    })
+        .then((key) => done(null, key), (error) => done(error, new Uint8Array(0)));
+};
+/**
+ * What hashing takes from Node.js: its `node:crypto` when it has `crypto.argon2`
+ * (Node.js 24.7.0 and later; `@node-rs/argon2` is then never loaded, installed or
+ * not), else the same with `@node-rs/argon2` behind `argon2`, else without `argon2`.
+ */
+export const passwordCryptoOf = (nodeCrypto, loadNodeRs) => {
+    if (typeof nodeCrypto.argon2 === "function") {
+        return nodeCrypto;
+    }
+    const nodeRs = loadNodeRs();
+    return {
+        ...(nodeCrypto.randomBytes === undefined
+            ? {}
+            : { randomBytes: nodeCrypto.randomBytes }),
+        ...(nodeCrypto.timingSafeEqual === undefined
+            ? {}
+            : { timingSafeEqual: nodeCrypto.timingSafeEqual }),
+        ...(nodeRs === undefined ? {} : { argon2: nodeRsArgon2(nodeRs) }),
+    };
+};

package/dist/passwords/passwords.options.d.ts

@@ -0,0 +1,79 @@
+import type { BetterAuthModules } from "../access/better-auth.loader.js";
+import { type AccessArgon2idProfile, type PasswordHook } from "./argon2id.hasher.js";
+/** The `passwords` block: the argon2id parameter profile passwords are hashed at. */
+export type AccessPasswordsOptions = {
+    /**
+     * `"owasp-minimum"` (the default: m=19456 KiB, t=2, p=1, OWASP's minimum) or
+     * `"rfc9106-low-memory"` (m=65536 KiB, t=3, p=4, RFC 9106's second recommended
+     * option). Hashes stored at another profile still verify, and each is rehashed
+     * at this profile at its account's next sign-in.
+     */
+    readonly argon2id: AccessArgon2idProfile;
+    /**
+     * `true`: passwords Better Auth hashed with scrypt still verify, and each is
+     * rehashed with argon2id at the user's next sign-in. Every sign-in then also costs
+     * one scrypt, so its time does not say which hash an account holds. Off by
+     * default: a scrypt hash fails the check.
+     */
+    readonly legacyScrypt?: boolean;
+};
+/** The `passwords` block, checked. */
+type PasswordsSettings = {
+    readonly profile: AccessArgon2idProfile;
+    readonly legacyScrypt: boolean;
+};
+/** The checked `passwords` block, `undefined` when it is absent. */
+export declare const checkPasswordsOptions: (passwords: unknown) => PasswordsSettings | undefined;
+/**
+ * The after hook that moves a password to the current profile: on a sign-in that
+ * started a session with a password, when Better Auth's password hook is Access's
+ * and the user's credential holds a hash {@link needsRehash} names (a scrypt hash
+ * under `legacyScrypt`, or argon2id at other parameters than the profile's), and
+ * this password matches it (checked again here, so no route's own reading of
+ * `password` is trusted), the password is hashed at the profile and stored in its
+ * place.
+ *
+ * The write is a compare-and-set through Better Auth's adapter: it changes the
+ * account only while it still holds the hash just checked. A password changed or
+ * reset meanwhile is never overwritten, and of two sign-ins at once the later write
+ * wins with an equally valid hash. It goes past Better Auth's account update hooks:
+ * the password is the same one, encoded anew. On a current hash it costs one read
+ * and nothing else. A failure is logged (never the password or a hash) and leaves
+ * the stored hash; the sign-in stands.
+ */
+export declare const passwordRehashHook: (modules: BetterAuthModules) => unknown;
+/**
+ * The password hook Better Auth runs with: argon2id at the checked block's profile,
+ * or `undefined` when the app set `emailAndPassword.password` itself (its hook
+ * passes through). `at` names that option as the app writes it.
+ */
+export declare const passwordHookOf: (settings: PasswordsSettings | undefined, emailAndPassword: unknown, modules: BetterAuthModules, 
+/** Better Auth's context, once it is built: where the hook logs. */
+context: () => Promise<unknown>, at: string) => PasswordHook | undefined;
+/**
+ * What `createAccess` builds Better Auth with for passwords: its `emailAndPassword`
+ * block, the app's with the argon2id hook in it, or `undefined` when the app set
+ * `password` itself and its block passes through as given; and, with the argon2id
+ * hook, the after hook the Access plugin adds to rehash a password at the profile.
+ */
+export declare const passwordsOf: (passwords: unknown, betterAuth: {
+    readonly [key: string]: unknown;
+}, modules: BetterAuthModules, 
+/** Better Auth's context, once it is built: where the hook logs. */
+context: () => Promise<unknown>) => {
+    readonly emailAndPassword: {
+        readonly [key: string]: unknown;
+    } | undefined;
+    /** The Access plugin's after hook that rehashes a password at the profile, with the argon2id hook. */
+    readonly rehash: unknown;
+};
+/**
+ * The kiosk profile's PIN hasher: argon2id at the `passwords` block's profile (the
+ * default without one), whatever hashes the app's passwords, since a PIN is a weak
+ * secret and its hash must be slow wherever it is read. A PIN is at most
+ * `maxPinLength` digits; Better Auth's scrypt hashes never verify as PINs.
+ */
+export declare const pinHasherOf: (passwords: unknown, modules: BetterAuthModules, 
+/** Better Auth's context, once it is built: where the hasher logs. */
+context: () => Promise<unknown>, maxPinLength: number) => PasswordHook;
+export {};