@nxgt/janus 0.16.0 → 0.17.0

package/dist/index.js

@@ -281,6 +281,13 @@ function unseal(sealer, sealed, boundTo, where) {
   }
 }
 
+// src/auth/config/resolve-devices.ts
+function resolveDevices(config, where) {
+  if (config === undefined)
+    return null;
+  return { sealer: resolveSealer(config?.keys, `${where}: devices.keys`) };
+}
+
 // src/auth/config/resolve-second-factor.ts
 function resolveSecondFactor(config, where) {
   if (config === undefined)
@@ -365,7 +372,8 @@ function resolveConfig(config, where) {
     tokenTtlMs: resolveTokenTtls(config, where),
     cookie: resolveCookie(config.cookie ?? {}, where),
     signInThrottle: resolveSignInThrottle(config.signIn, where),
-    secondFactor: resolveSecondFactor(config.secondFactor, where)
+    secondFactor: resolveSecondFactor(config.secondFactor, where),
+    devices: resolveDevices(config.devices, where)
   };
 }
 function entriesOf(config, hasUsers) {
@@ -725,10 +733,105 @@ function assertStores(stores, where) {
   return { collectExpired: collect !== undefined };
 }
 
+// src/auth/devices/token.ts
+import { randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+
+// src/auth/derived-keys.ts
+import { createHmac, hkdfSync } from "node:crypto";
+var derived = new WeakMap;
+function derivedKey(sealer, purpose, keyId = sealer.sealWith) {
+  let keys = derived.get(sealer);
+  if (keys === undefined) {
+    keys = new Map;
+    derived.set(sealer, keys);
+  }
+  const name = `${purpose}\x00${keyId}`;
+  let key = keys.get(name);
+  if (key === undefined) {
+    const secret = sealer.keys.get(keyId);
+    if (secret === undefined)
+      return;
+    key = Buffer.from(hkdfSync("sha256", secret, Buffer.alloc(0), purpose, 32));
+    keys.set(name, key);
+  }
+  return key;
+}
+function keyedHash(key, parts) {
+  return createHmac("sha256", key).update(parts.join("\x00")).digest();
+}
+
+// src/auth/devices/token.ts
+var PURPOSE = "janus/devices/v1";
+var TOKEN = /^d1\.([A-Za-z0-9_-]{1,64})\.([A-Za-z0-9_-]{22})\.([A-Za-z0-9_-]{43})$/;
+function macOf(key, userId, deviceId) {
+  return keyedHash(key, [userId, deviceId]);
+}
+function signed(sealer, userId, deviceId) {
+  const key = derivedKey(sealer, PURPOSE);
+  const mac = macOf(key, userId, deviceId).toString("base64url");
+  return `d1.${sealer.sealWith}.${deviceId}.${mac}`;
+}
+function mintDeviceToken(sealer, userId) {
+  return signed(sealer, userId, randomBytes3(16).toString("base64url"));
+}
+function knownDeviceToken(sealer, userId, presented) {
+  const [, keyId, deviceId, mac] = TOKEN.exec(presented) ?? [];
+  if (keyId === undefined || deviceId === undefined || mac === undefined) {
+    return null;
+  }
+  const key = derivedKey(sealer, PURPOSE, keyId);
+  if (key === undefined)
+    return null;
+  const expected = macOf(key, userId, deviceId);
+  const given = Buffer.from(mac, "base64url");
+  if (given.length !== expected.length || !timingSafeEqual2(given, expected)) {
+    return null;
+  }
+  return keyId === sealer.sealWith ? presented : signed(sealer, userId, deviceId);
+}
+
+// src/auth/devices/hint.ts
+var UNTRACKED = Object.freeze({
+  newDevice: false,
+  deviceToken: null
+});
+function deviceHint(context, options, where) {
+  if (options !== undefined && (typeof options !== "object" || options === null)) {
+    throw new TypeError(`${where}: options must be { device }, or left out — the token goes under device`);
+  }
+  const device = options?.device;
+  if (device === undefined)
+    return;
+  if (device !== null && typeof device !== "string") {
+    throw new TypeError(`${where}: options.device must be the device token the client holds, or null when it holds none`);
+  }
+  if (context.config.devices === null) {
+    throw new TypeError(`${where}: a device was given, but janus() has no devices — pass devices: { keys }`);
+  }
+  return device;
+}
+function deviceOutcome(context, userId, hint, signUp) {
+  const sealer = context.config.devices?.sealer;
+  if (hint === undefined || sealer === undefined)
+    return UNTRACKED;
+  const known = hint === null || signUp ? null : knownDeviceToken(sealer, userId, hint);
+  if (known !== null)
+    return { newDevice: false, deviceToken: known };
+  return {
+    newDevice: !signUp,
+    deviceToken: mintDeviceToken(sealer, userId)
+  };
+}
+// src/auth/devices/report.ts
+async function reportNewDevice(context, result) {
+  if (result.status !== "signedIn" || !result.newDevice)
+    return;
+  await emit(context, "user.newDeviceSignedIn", result.user, result.session.createdAt, { sessionId: result.session.id });
+}
 // src/auth/secrets.ts
-import { createHash, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash, randomBytes as randomBytes4 } from "node:crypto";
 function mintSecret() {
-  return randomBytes3(32).toString("base64url");
+  return randomBytes4(32).toString("base64url");
 }
 function hashSecret(secret) {
   return createHash("sha256").update(secret).digest("hex");
@@ -739,7 +842,7 @@ function toSession(record) {
   const { tokenHash: _, ...session } = record;
   return session;
 }
-async function openSession(context, type, user) {
+async function openSession(context, type, user, device, signUp = false) {
   const now = context.clock.now();
   const token = mintSecret();
   const record = {
@@ -756,7 +859,8 @@ async function openSession(context, type, user) {
     status: "signedIn",
     user: toUser(user),
     session: toSession(record),
-    token
+    token,
+    ...deviceOutcome(context, user.id, device, signUp)
   };
 }
 // src/auth/sessions/presented-token.ts
@@ -905,7 +1009,7 @@ function sharedApi(context) {
   };
 }
 // src/auth/one-time/codes.ts
-import { timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { timingSafeEqual as timingSafeEqual3 } from "node:crypto";
 
 // src/auth/one-time/refusals.ts
 function refuseStale(type, user, token, where, noun) {
@@ -974,7 +1078,7 @@ function codeMatches(token, challenge, code) {
     return false;
   const given = Buffer.from(hashCode(challenge, code));
   const held = Buffer.from(token.codeHash);
-  return given.length === held.length && timingSafeEqual2(given, held);
+  return given.length === held.length && timingSafeEqual3(given, held);
 }
 // src/auth/one-time/issue.ts
 import { randomInt } from "node:crypto";
@@ -1201,11 +1305,11 @@ function emailFlows(context, type, at) {
   };
 }
 // src/auth/totp.ts
-import { createHmac, randomBytes as randomBytes4 } from "node:crypto";
+import { createHmac as createHmac2, randomBytes as randomBytes5 } from "node:crypto";
 var TOTP = { digits: 6, stepMs: 30000, drift: 1 };
 var BASE32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 function mintTotpSecret() {
-  return toBase32(randomBytes4(20));
+  return toBase32(randomBytes5(20));
 }
 function toBase32(bytes) {
   let bits = 0;
@@ -1244,7 +1348,7 @@ var stepAt = (now) => Math.floor(now.getTime() / TOTP.stepMs);
 function codeAt(secret, step) {
   const counter = Buffer.alloc(8);
   counter.writeBigUInt64BE(BigInt(step));
-  const digest = createHmac("sha1", secret).update(counter).digest();
+  const digest = createHmac2("sha1", secret).update(counter).digest();
   const offset = digest[19] & 15;
   const binary = digest.readUInt32BE(offset) & 2147483647;
   return String(binary % 10 ** TOTP.digits).padStart(TOTP.digits, "0");
@@ -1343,7 +1447,7 @@ async function keepOnlyLatest(context, userId, kind, secret) {
   await context.store.tokens.spendUserTokens(userId, kind, context.clock.now(), hashSecret(secret));
 }
 async function finishEmailSignIn(context, type, finish, signIn) {
-  const { user, token, where, noun } = signIn;
+  const { user, token, where, noun, device } = signIn;
   refuseStale(type, user, token, where, noun);
   if (!user.active) {
     throw new UserInactiveError2(`${where}: the user is inactive`, {
@@ -1351,9 +1455,10 @@ async function finishEmailSignIn(context, type, finish, signIn) {
       userType: type.name
     });
   }
-  if (user.emailVerifiedAt !== null)
-    return finish(user, where);
-  return finish(await proveFirstEmail(context, type, user, where), where);
+  const proved = user.emailVerifiedAt !== null ? user : await proveFirstEmail(context, type, user, where);
+  const result = await finish(proved, where, device);
+  await reportNewDevice(context, result);
+  return result;
 }
 
 // src/auth/magic-link.ts
@@ -1362,8 +1467,10 @@ function magicLinkFlows(context, type, at, finish) {
     async request(email) {
       return requestLink(context, type, String(email));
     },
-    async confirm(token) {
-      return confirmLink(context, type, finish, String(token), at("magicLink.confirm"));
+    async confirm(token, options) {
+      const where = at("magicLink.confirm");
+      const device = deviceHint(context, options, where);
+      return confirmLink(context, type, finish, String(token), where, device);
     }
   };
 }
@@ -1381,46 +1488,23 @@ async function requestLink(context, type, email) {
   await keepOnlyLatest(context, record.id, "magicLink", secret);
   return { token: secret, email: address, expiresAt, user: toUser(record) };
 }
-async function confirmLink(context, type, finish, secret, where) {
+async function confirmLink(context, type, finish, secret, where, device) {
   const { token, user } = await redeemEmailToken(context, type, "magicLink", secret, where);
   return finishEmailSignIn(context, type, finish, {
     user,
     token,
     where,
-    noun: "token"
+    noun: "token",
+    device
   });
 }
 
-// src/auth/derived-keys.ts
-import { createHmac as createHmac2, hkdfSync } from "node:crypto";
-var derived = new WeakMap;
-function derivedKey(sealer, purpose, keyId = sealer.sealWith) {
-  let keys = derived.get(sealer);
-  if (keys === undefined) {
-    keys = new Map;
-    derived.set(sealer, keys);
-  }
-  const name = `${purpose}\x00${keyId}`;
-  let key = keys.get(name);
-  if (key === undefined) {
-    const secret = sealer.keys.get(keyId);
-    if (secret === undefined)
-      return;
-    key = Buffer.from(hkdfSync("sha256", secret, Buffer.alloc(0), purpose, 32));
-    keys.set(name, key);
-  }
-  return key;
-}
-function keyedHash(key, parts) {
-  return createHmac2("sha256", key).update(parts.join("\x00")).digest();
-}
-
 // src/auth/sign-in-attempts.ts
-var PURPOSE = "janus/sign-in/attempts/v1";
-var UNSEALED = Buffer.from(PURPOSE);
+var PURPOSE2 = "janus/sign-in/attempts/v1";
+var UNSEALED = Buffer.from(PURPOSE2);
 function counterKey(context) {
   const sealer = context.config.secondFactor?.sealer;
-  return sealer === undefined ? UNSEALED : derivedKey(sealer, PURPOSE);
+  return sealer === undefined ? UNSEALED : derivedKey(sealer, PURPOSE2);
 }
 var keyed = (key, parts) => keyedHash(key, parts).toString("base64url");
 async function countLogin(context, type, login, where) {
@@ -1515,13 +1599,14 @@ function challengeFlows(context, type, at) {
         userId: record.id
       };
     },
-    async confirm(challenge, code) {
-      return confirmChallenge(context, type, challenge, code, at);
+    async confirm(challenge, code, options) {
+      return confirmChallenge(context, type, challenge, code, at, options);
     }
   };
 }
-async function confirmChallenge(context, type, challenge, code, at) {
+async function confirmChallenge(context, type, challenge, code, at, options) {
   const where = at("secondFactor.confirm");
+  const device = deviceHint(context, options, where);
   const opened = await openChallenge(context, type, challenge, where);
   const { record } = opened;
   const now = context.clock.now();
@@ -1531,7 +1616,9 @@ async function confirmChallenge(context, type, challenge, code, at) {
   const written = await context.store.users.updateUser(record.id, { secondFactor: accepted, updatedAt: now }, record.version);
   await spendChallenge(context, opened.secret, where);
   await restartSignInCount(context, type, written, where);
-  return openSession(context, type, written);
+  const signedIn = await openSession(context, type, written, device);
+  await reportNewDevice(context, signedIn);
+  return signedIn;
 }
 
 // src/auth/second-factor/codes-left.ts
@@ -1542,12 +1629,12 @@ async function recoveryCodesLeftOf(context, type, user, where) {
 }
 
 // src/auth/second-factor/recovery-codes.ts
-import { randomInt as randomInt2, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { randomInt as randomInt2, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
 var RECOVERY_CODES = 10;
 var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
 var LENGTH = 10;
 var SHAPE = /^[0-9a-hjkmnp-tv-z]{10}$/;
-var PURPOSE2 = "janus/second-factor/recovery-codes/v1";
+var PURPOSE3 = "janus/second-factor/recovery-codes/v1";
 function mintRecoveryCodes() {
   return Array.from({ length: RECOVERY_CODES }, () => {
     let code = "";
@@ -1561,7 +1648,7 @@ function readRecoveryCode(typed) {
   const code = typed.toLowerCase().replace(/[\s-]/g, "").replace(/o/g, "0").replace(/[il]/g, "1");
   return SHAPE.test(code) ? code : null;
 }
-var macKey = (sealer, keyId) => derivedKey(sealer, PURPOSE2, keyId);
+var macKey = (sealer, keyId) => derivedKey(sealer, PURPOSE3, keyId);
 var mac = (key, userId, code) => keyedHash(key, [userId, code]);
 function hashRecoveryCode(sealer, userId, code) {
   const read = readRecoveryCode(code) ?? code;
@@ -1584,7 +1671,7 @@ function findRecoveryCode(sealer, userId, hashes, typed, where) {
       return;
     const held = Buffer.from(body, "base64url");
     const given = mac(key, userId, code);
-    if (held.length === given.length && timingSafeEqual3(held, given)) {
+    if (held.length === given.length && timingSafeEqual4(held, given)) {
       found = found === -1 ? index : found;
     }
   });
@@ -1672,7 +1759,7 @@ function accountOf(type, record, where) {
 // src/auth/second-factor/app-code-attempts.ts
 var APP_CODE_WINDOW_MS = 15 * 60000;
 var WINDOW_MINUTES = APP_CODE_WINDOW_MS / 60000;
-var PURPOSE3 = "janus/second-factor/regenerate-attempts/v1";
+var PURPOSE4 = "janus/second-factor/regenerate-attempts/v1";
 function linkHash(sealer, record, window, link) {
   const parts = [
     record.id,
@@ -1680,7 +1767,7 @@ function linkHash(sealer, record, window, link) {
     String(record.secondFactor?.lastStep ?? ""),
     String(link)
   ];
-  const key = derivedKey(sealer, PURPOSE3);
+  const key = derivedKey(sealer, PURPOSE4);
   return hashSecret(keyedHash(key, parts).toString("base64url"));
 }
 async function countAppCodeAttempt(context, sealer, record, where) {
@@ -1750,9 +1837,11 @@ function lifecycleFlows(context, type, at) {
 }
 
 // src/auth/second-factor/recovery.ts
-async function recoverWithCode(context, type, challenge, code, at) {
+async function recoverWithCode(context, type, given, at) {
   const where = at("secondFactor.recover");
-  const opened = await openChallenge(context, type, challenge, where);
+  const device = deviceHint(context, given.options, where);
+  const { code } = given;
+  const opened = await openChallenge(context, type, given.challenge, where);
   const { record } = opened;
   const factor = record.secondFactor;
   const found = findRecoveryCode(opened.configured.sealer, record.id, factor.recoveryCodes, String(code), where);
@@ -1763,14 +1852,16 @@ async function recoverWithCode(context, type, challenge, code, at) {
     secondFactor: { ...factor, recoveryCodes },
     updatedAt: context.clock.now()
   }, record.version);
+  let signedIn;
   try {
     await spendChallenge(context, opened.secret, where);
     await restartSignInCount(context, type, written, where);
-    const signedIn = await openSession(context, type, written);
-    return { ...signedIn, recoveryCodesLeft: recoveryCodes.length };
+    signedIn = await openSession(context, type, written, device);
   } finally {
     await emit(context, "user.recoveryCodeUsed", written, written.updatedAt);
   }
+  await reportNewDevice(context, signedIn);
+  return { ...signedIn, recoveryCodesLeft: recoveryCodes.length };
 }
 
 // src/auth/second-factor/flows.ts
@@ -1779,12 +1870,12 @@ function secondFactorFlows(context, type, at) {
   const api = {
     ...lifecycleFlows(context, type, at),
     confirm: challenges.confirm,
-    recover: (challenge, code) => recoverWithCode(context, type, challenge, code, at),
+    recover: (challenge, code, options) => recoverWithCode(context, type, { challenge, code, options }, at),
     recoveryCodesLeft: (user) => recoveryCodesLeftOf(context, type, user, at("secondFactor.recoveryCodesLeft"))
   };
   return {
     api,
-    finish: (record, where) => isActive(record.secondFactor) ? challenges.issue(record, where) : openSession(context, type, record)
+    finish: (record, where, device) => isActive(record.secondFactor) ? challenges.issue(record, where) : openSession(context, type, record, device)
   };
 }
 
@@ -1794,8 +1885,8 @@ function signInCodeFlows(context, type, at, finish) {
     async request(email) {
       return requestCode(context, type, String(email));
     },
-    async confirm(challenge, code) {
-      return confirmCode(context, type, finish, challenge, code, at);
+    async confirm(challenge, code, options) {
+      return confirmCode(context, type, finish, { challenge, code, options }, at);
     }
   };
 }
@@ -1818,9 +1909,11 @@ async function requestCode(context, type, email) {
     user: toUser(record)
   };
 }
-async function confirmCode(context, type, finish, challenge, code, at) {
+async function confirmCode(context, type, finish, given, at) {
   const where = at("signInCode.confirm");
-  const secret = String(challenge);
+  const device = deviceHint(context, given.options, where);
+  const secret = String(given.challenge);
+  const code = given.code;
   const { token, attemptsLeft } = await countCodeAttempt(context, secret, "signInCode", where, type.name);
   const user = await findRecord(context, token.userId, type.name);
   if (user === null) {
@@ -1837,7 +1930,8 @@ async function confirmCode(context, type, finish, challenge, code, at) {
     user,
     token,
     where,
-    noun: "code"
+    noun: "code",
+    device
   });
 }
 
@@ -2037,7 +2131,8 @@ async function insert(context, type, input, where) {
 }
 
 // src/auth/users/sign-in.ts
-async function signIn(context, type, finish, input, where) {
+async function signIn(context, type, finish, input, call) {
+  const { where, device } = call;
   const rule = passwordRule(type, where);
   const hasher = requireHasher(context, where);
   const login = input?.[rule.login];
@@ -2065,27 +2160,31 @@ async function signIn(context, type, finish, input, where) {
     await restartSignInCount(context, type, record, where);
   }
   const verified = await rehashed(context, record, String(password));
-  const result = await finish(verified, where);
+  const result = await finish(verified, where, device);
   if (!await heldByPassword(context, type, verified, String(password), result, where)) {
     throw refuse("wrongPassword");
   }
+  await reportNewDevice(context, result);
   return result;
 }
 
 // src/auth/users/password-flows.ts
 function passwordFlows(context, type, at, finish) {
   return {
-    async signUp(input) {
+    async signUp(input, options) {
       const where = at("signUp");
+      const device = deviceHint(context, options, where);
       passwordRule(type, where);
       if (input?.password === undefined) {
         checkPassword(type, undefined, where);
       }
       const record = await insert(context, type, input, where);
-      return openSession(context, type, record);
+      return openSession(context, type, record, device, true);
     },
-    async signIn(input) {
-      return signIn(context, type, finish, input, at("signIn"));
+    async signIn(input, options) {
+      const where = at("signIn");
+      const device = deviceHint(context, options, where);
+      return signIn(context, type, finish, input, { where, device });
     },
     async findByLogin(login) {
       const rule = passwordRule(type, at("findByLogin"));
@@ -2300,5 +2399,5 @@ export {
   systemClock
 };
 
-//# debugId=BC1254710D035B0264756E2164756E21
+//# debugId=735288C311F315A564756E2164756E21
 //# sourceMappingURL=index.js.map