@arbidocs/client 0.4.85 → 0.4.86

package/dist/index.js

@@ -365,70 +365,98 @@ async function generateUserKeypairs(username, password, deploymentDomain) {
     encryptionKeyPair
   };
 }
+var IDENTITY_WRAP_CONTEXT = "arbi-identity-wrap-v1";
+function identityWrappingKey(passwordSecretKey) {
+  return sodium.crypto_generichash(
+    32,
+    sodium.from_string(IDENTITY_WRAP_CONTEXT),
+    passwordSecretKey.slice(0, 32)
+  );
+}
+function generateIdentityKeypair() {
+  return generateRandomSigningKeypair();
+}
+function wrapIdentityKey(identitySecretKey, passwordSecretKey) {
+  const nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
+  const key = identityWrappingKey(passwordSecretKey);
+  try {
+    const boxed = sodium.crypto_secretbox_easy(identitySecretKey, nonce, key);
+    const out = new Uint8Array(nonce.length + boxed.length);
+    out.set(nonce);
+    out.set(boxed, nonce.length);
+    return base64Encode(out);
+  } finally {
+    key.fill(0);
+  }
+}
+function unwrapIdentityKey(wrapped, passwordSecretKey) {
+  if (!wrapped) return passwordSecretKey;
+  const bytes = base64Decode(wrapped);
+  const nonce = bytes.slice(0, sodium.crypto_secretbox_NONCEBYTES);
+  const key = identityWrappingKey(passwordSecretKey);
+  try {
+    return sodium.crypto_secretbox_open_easy(
+      bytes.slice(sodium.crypto_secretbox_NONCEBYTES),
+      nonce,
+      key
+    );
+  } catch {
+    throw new Error("Incorrect password");
+  } finally {
+    key.fill(0);
+  }
+}
 
 // src/crypto/credentials.ts
+function signedNow(email, key) {
+  const timestamp = Math.floor(Date.now() / 1e3);
+  return { signature: signMessage(`${email}|${timestamp}`, key), timestamp };
+}
 async function generateRegistrationCredentials(registrationData, password, deploymentDomain) {
-  const { signingKeyPair } = await generateUserKeypairs(
+  const { signingKeyPair: passwordKey } = await generateUserKeypairs(
     registrationData.email,
     password,
     deploymentDomain
   );
+  const identity = generateIdentityKeypair();
   const request = {
     ...registrationData,
-    signing_key: base64Encode(signingKeyPair.publicKey)
+    signing_key: base64Encode(identity.publicKey),
+    login_key: base64Encode(passwordKey.publicKey),
+    wrapped_identity_key: wrapIdentityKey(identity.secretKey, passwordKey.secretKey)
   };
-  return { request, signingPrivateKey: signingKeyPair.secretKey };
+  return { request, signingPrivateKey: identity.secretKey };
 }
 async function generateLoginCredentials(loginData, password, deploymentDomain) {
   const { signingKeyPair } = await generateUserKeypairs(loginData.email, password, deploymentDomain);
-  const timestamp = Math.floor(Date.now() / 1e3);
-  const message = `${loginData.email}|${timestamp}`;
-  const signature = signMessage(message, signingKeyPair.secretKey);
-  const request = {
-    ...loginData,
-    signature,
-    timestamp
+  return {
+    request: { ...loginData, ...signedNow(loginData.email, signingKeyPair.secretKey) },
+    passwordPrivateKey: signingKeyPair.secretKey
   };
-  return { request, signingPrivateKey: signingKeyPair.secretKey };
 }
 function generateLoginCredentialsFromKey(loginData, signingPrivateKey) {
   if (signingPrivateKey.length !== 64) {
     throw new Error("Invalid signing key: must be exactly 64 bytes");
   }
-  const timestamp = Math.floor(Date.now() / 1e3);
-  const message = `${loginData.email}|${timestamp}`;
-  const signature = signMessage(message, signingPrivateKey);
-  const request = {
-    ...loginData,
-    signature,
-    timestamp
-  };
-  return { request, signingPrivateKey };
-}
-async function generatePasswordChangeCredentials(email, currentPassword, newPassword, deploymentDomain) {
-  const currentKeypairs = await generateUserKeypairs(email, currentPassword, deploymentDomain);
-  const newKeypairs = await generateUserKeypairs(email, newPassword, deploymentDomain);
-  const timestamp = Math.floor(Date.now() / 1e3);
-  const message = `${email}|${timestamp}`;
-  const signature = signMessage(message, currentKeypairs.signingKeyPair.secretKey);
-  const request = {
-    signature,
-    timestamp,
-    new_signing_key: base64Encode(newKeypairs.signingKeyPair.publicKey)
+  return {
+    request: { ...loginData, ...signedNow(loginData.email, signingPrivateKey) },
+    signingPrivateKey
   };
-  return { request, newSigningPrivateKey: newKeypairs.signingKeyPair.secretKey };
 }
-async function generateRecoveryPasswordChangeCredentials(email, currentSigningKey, newPassword, deploymentDomain) {
-  const newKeypairs = await generateUserKeypairs(email, newPassword, deploymentDomain);
-  const timestamp = Math.floor(Date.now() / 1e3);
-  const message = `${email}|${timestamp}`;
-  const signature = signMessage(message, currentSigningKey);
-  const request = {
-    signature,
-    timestamp,
-    new_signing_key: base64Encode(newKeypairs.signingKeyPair.publicKey)
+async function generatePasswordChangeCredentials(params, deploymentDomain) {
+  const signer = params.currentPassword ? (await generateUserKeypairs(params.email, params.currentPassword, deploymentDomain)).signingKeyPair.secretKey : params.identitySecretKey;
+  const { signingKeyPair: newPasswordKey } = await generateUserKeypairs(
+    params.email,
+    params.newPassword,
+    deploymentDomain
+  );
+  return {
+    request: {
+      ...signedNow(params.email, signer),
+      new_login_key: base64Encode(newPasswordKey.publicKey),
+      wrapped_identity_key: wrapIdentityKey(params.identitySecretKey, newPasswordKey.secretKey)
+    }
   };
-  return { request, newSigningPrivateKey: newKeypairs.signingKeyPair.secretKey };
 }
 
 // src/middleware/bearer-auth.ts
@@ -594,7 +622,8 @@ function createReloginHandler(deps) {
         await deps.sessionStorage.saveSession({
           signingPrivateKey: session.signingPrivateKey,
           serverSessionKey: loginResult.sessionKey,
-          userExtId: loginResult.userExtId
+          userExtId: loginResult.userExtId,
+          wrappedIdentityKey: loginResult.wrappedIdentityKey ?? null
         });
         await deps.onReloginSuccess?.({
           email: userEmail,
@@ -845,6 +874,7 @@ async function saveSession(sessionData) {
         encryptedServerSessionKey: encryptedServerSessionKey?.ciphertext,
         serverSessionKeyIV: encryptedServerSessionKey?.iv,
         userExtId: sessionData.userExtId,
+        wrappedIdentityKey: sessionData.wrappedIdentityKey ?? null,
         timestamp: Date.now()
       };
       const request = store.put(data);
@@ -895,7 +925,8 @@ async function getSession() {
           resolve({
             signingPrivateKey,
             serverSessionKey,
-            userExtId: result.userExtId
+            userExtId: result.userExtId,
+            wrappedIdentityKey: result.wrappedIdentityKey ?? null
           });
         } catch (error) {
           console.error("[STORAGE] Failed to decrypt session data:", error);
@@ -911,22 +942,12 @@ async function getSession() {
     };
   });
 }
-async function updateSigningPrivateKey(newSigningPrivateKey) {
-  await ensureDatabase();
-  try {
-    const existingSession = await getSession();
-    if (!existingSession) {
-      throw new Error("No existing session to update");
-    }
-    await saveSession({
-      signingPrivateKey: newSigningPrivateKey,
-      serverSessionKey: existingSession.serverSessionKey,
-      userExtId: existingSession.userExtId
-    });
-  } catch (error) {
-    console.error("[STORAGE] Failed to update signing private key:", error);
-    throw error;
+async function updateWrappedIdentityKey(wrappedIdentityKey) {
+  const existingSession = await getSession();
+  if (!existingSession) {
+    throw new Error("No existing session to update");
   }
+  await saveSession({ ...existingSession, wrappedIdentityKey });
 }
 async function clearSession() {
   memorySession = null;
@@ -1025,6 +1046,34 @@ async function register(params, deps) {
   return { signingPrivateKey: credentials.signingPrivateKey };
 }
 
+// src/auth/identity.ts
+function bytesEqual(a, b) {
+  return a.length === b.length && a.every((byte, i) => byte === b[i]);
+}
+function encryptionPublicKeyOf(identitySecretKey) {
+  return base64Encode(
+    deriveEncryptionKeypairFromSigning({
+      publicKey: identitySecretKey.slice(32, 64),
+      secretKey: identitySecretKey
+    }).publicKey
+  );
+}
+function identityFromLoginResponse(passwordPrivateKey, response) {
+  const identity = unwrapIdentityKey(response.wrapped_identity_key, passwordPrivateKey);
+  if (encryptionPublicKeyOf(identity) !== response.user.encryption_public_key) {
+    throw new Error("The account key does not match this account");
+  }
+  return identity;
+}
+async function unlockIdentityWithPassword(email, password, deploymentDomain) {
+  const session = await getSession();
+  if (!session?.signingPrivateKey) throw new Error("No active session found");
+  const { signingKeyPair } = await generateUserKeypairs(email, password, deploymentDomain);
+  const identity = unwrapIdentityKey(session.wrappedIdentityKey, signingKeyPair.secretKey);
+  if (!bytesEqual(identity, session.signingPrivateKey)) throw new Error("Incorrect password");
+  return session.signingPrivateKey;
+}
+
 // src/auth/login.ts
 async function login(params, deps) {
   const credentials = await generateLoginCredentials(
@@ -1035,7 +1084,7 @@ async function login(params, deps) {
     params.password,
     deps.deploymentDomain
   );
-  return performLogin(credentials.request, credentials.signingPrivateKey, deps);
+  return performLogin(credentials.request, { password: credentials.passwordPrivateKey }, deps);
 }
 async function loginWithKey(params, deps) {
   const credentials = generateLoginCredentialsFromKey(
@@ -1045,9 +1094,9 @@ async function loginWithKey(params, deps) {
     },
     params.signingPrivateKey
   );
-  return performLogin(credentials.request, credentials.signingPrivateKey, deps);
+  return performLogin(credentials.request, { identity: credentials.signingPrivateKey }, deps);
 }
-async function performLogin(request, signingPrivateKey, deps) {
+async function performLogin(request, signer, deps) {
   const response = await deps.fetchClient.POST("/v1/user/login", {
     body: request
   });
@@ -1058,10 +1107,12 @@ async function performLogin(request, signingPrivateKey, deps) {
   }
   const data = response.data;
   const serverSessionKey = base64ToBytes(data.session_key);
+  const signingPrivateKey = "password" in signer ? identityFromLoginResponse(signer.password, data) : signer.identity;
   await saveSession({
     signingPrivateKey,
     serverSessionKey,
-    userExtId: data.user.external_id ?? void 0
+    userExtId: data.user.external_id ?? void 0,
+    wrappedIdentityKey: data.wrapped_identity_key ?? null
   });
   deps.session.setAccessToken(data.access_token);
   deps.session.setUser(request.email, data.user.external_id ?? void 0);
@@ -1089,40 +1140,6 @@ async function logout(session) {
 }
 
 // src/auth/change-password.ts
-var passwordCalls = (client) => client;
-async function changePassword(params, deps) {
-  const credentials = await generatePasswordChangeCredentials(
-    params.email,
-    params.currentPassword,
-    params.newPassword,
-    deps.deploymentDomain
-  );
-  const stored = await getSession();
-  if (!stored) throw new Error("Sign in to change your password");
-  const current = deriveEncryptionKeypairFromSigning({
-    publicKey: stored.signingPrivateKey.slice(32, 64),
-    secretKey: stored.signingPrivateKey
-  });
-  const next = deriveEncryptionKeypairFromSigning({
-    publicKey: credentials.newSigningPrivateKey.slice(32, 64),
-    secretKey: credentials.newSigningPrivateKey
-  });
-  const mailKeys = await rewrapMailKeys(deps.fetchClient, current.secretKey, next.publicKey);
-  const response = await passwordCalls(deps.fetchClient).POST("/v1/user/change_password", {
-    body: {
-      ...credentials.request,
-      ...mailKeys,
-      rewrapped_workspace_keys: params.rewrappedWorkspaceKeys ?? {}
-    }
-  });
-  if (response.error) {
-    throw new Error(
-      `Password change failed: ${typeof response.error === "object" && response.error !== null && "detail" in response.error ? response.error.detail : "Unknown error"}`
-    );
-  }
-  await updateSigningPrivateKey(credentials.newSigningPrivateKey);
-  return { newSigningPrivateKey: credentials.newSigningPrivateKey };
-}
 function passwordChangeErrorMessage(err) {
   if (err instanceof Error) return err.message;
   if (err && typeof err === "object") {
@@ -1138,140 +1155,24 @@ function passwordChangeErrorMessage(err) {
   }
   return "Failed to change password";
 }
-async function reEncryptDirectMessages(fetchClient, userExtId, oldSecretKey, newSecretKey) {
-  const { data } = await fetchClient.GET("/v1/notifications/");
-  const messages = (data ?? []).filter(
-    (n) => n.type === "user_message" && (n.content || n.attachments)
-  );
-  const oldSecrets = {};
-  const newSecrets = {};
-  const updates = [];
-  for (const n of messages) {
-    try {
-      const other = n.sender.external_id === userExtId ? n.recipient : n.sender;
-      const id = other.external_id;
-      oldSecrets[id] ??= await computeSharedSecret(other.encryption_public_key, oldSecretKey);
-      newSecrets[id] ??= await computeSharedSecret(other.encryption_public_key, newSecretKey);
-      const reEncrypt = async (ciphertext) => encryptMessageWithSharedSecret(
-        await decryptMessageWithSharedSecret(ciphertext, oldSecrets[id]),
-        newSecrets[id]
-      );
-      const content = n.content ? await reEncrypt(n.content) : void 0;
-      const attachments = n.attachments ? await reEncrypt(n.attachments) : void 0;
-      updates.push({
-        external_id: n.external_id,
-        ...content !== void 0 ? { content } : {},
-        ...attachments !== void 0 ? { attachments } : {}
-      });
-    } catch {
-    }
-  }
-  if (updates.length === 0) return 0;
-  const patched = await fetchClient.PATCH("/v1/notifications/", { body: { updates } });
-  if (!patched.data) throw new Error("Failed to save re-encrypted messages");
-  return updates.length;
-}
-async function rewrapMailKeys(fetchClient, oldPrivateKey, newPublicKey) {
-  const rewrappedMailKeys = {};
-  let mailCursor = 0;
-  while (mailCursor !== null) {
-    const result = await fetchClient.GET(
-      "/v1/mail/native/keys",
-      {
-        params: { query: { cursor: mailCursor } }
-      }
-    );
-    if (!result.data) throw new Error("Could not load mailbox keys for password change");
-    for (const [id, wrapped] of Object.entries(result.data.keys)) {
-      const key = sealedBoxDecrypt(wrapped, oldPrivateKey);
-      try {
-        rewrappedMailKeys[id] = sealedBoxEncrypt(key, newPublicKey);
-      } finally {
-        key.fill(0);
-      }
-    }
-    mailCursor = result.data.next_cursor ?? null;
-  }
-  const connected = await passwordCalls(fetchClient).GET("/v1/mail/native/rotation-credentials");
-  if (!connected.data) throw new Error("Could not load mail connections for password change");
-  const rewrappedMailCredentials = {};
-  for (const [id, wrapped] of Object.entries(connected.data)) {
-    const plain = sealedBoxDecrypt(wrapped, oldPrivateKey);
-    try {
-      rewrappedMailCredentials[id] = sealedBoxEncrypt(plain, newPublicKey);
-    } finally {
-      plain.fill(0);
-    }
-  }
-  return {
-    rewrapped_mail_keys: rewrappedMailKeys,
-    rewrapped_mail_credentials: rewrappedMailCredentials
-  };
-}
-async function changePasswordWithRekey(params, deps) {
-  const session = await getSession();
-  if (!session) throw new Error("No active session found");
-  const { request, newSigningPrivateKey } = params.currentPassword ? await generatePasswordChangeCredentials(
-    params.email,
-    params.currentPassword,
-    params.newPassword,
-    deps.deploymentDomain
-  ) : await generateRecoveryPasswordChangeCredentials(
-    params.email,
-    session.signingPrivateKey,
-    params.newPassword,
+async function changePassword(params, deps) {
+  const fromStore = !params.identitySecretKey;
+  const identitySecretKey = params.identitySecretKey ?? (await getSession())?.signingPrivateKey;
+  if (!identitySecretKey) throw new Error("Sign in to change your password");
+  const { request } = await generatePasswordChangeCredentials(
+    {
+      email: params.email,
+      identitySecretKey,
+      newPassword: params.newPassword,
+      currentPassword: params.currentPassword
+    },
     deps.deploymentDomain
   );
-  const current = deriveEncryptionKeypairFromSigning({
-    publicKey: session.signingPrivateKey.slice(32, 64),
-    secretKey: session.signingPrivateKey
-  });
-  const next = deriveEncryptionKeypairFromSigning({
-    publicKey: newSigningPrivateKey.slice(32, 64),
-    secretKey: newSigningPrivateKey
-  });
-  const listed = await deps.fetchClient.GET("/v1/user/workspaces");
-  if (!listed.data) throw new Error("Could not list your workspaces");
-  const rewrapped = {};
-  for (const ws of listed.data.filter((w) => w.is_member)) {
-    if (!ws.wrapped_key) continue;
-    try {
-      rewrapped[ws.external_id] = sealedBoxEncrypt(
-        sealedBoxDecrypt(ws.wrapped_key, current.secretKey),
-        next.publicKey
-      );
-    } catch {
-      throw new Error(`Failed to re-wrap workspace key for ${ws.name || ws.external_id}`);
-    }
-  }
-  let messagesReEncrypted = 0;
-  if (params.userExtId) {
-    try {
-      messagesReEncrypted = await reEncryptDirectMessages(
-        deps.fetchClient,
-        params.userExtId,
-        current.secretKey,
-        next.secretKey
-      );
-    } catch {
-    }
-  }
-  const mailKeys = await rewrapMailKeys(deps.fetchClient, current.secretKey, next.publicKey);
-  const response = await passwordCalls(deps.fetchClient).POST("/v1/user/change_password", {
-    body: {
-      ...request,
-      rewrapped_workspace_keys: rewrapped,
-      ...mailKeys
-    }
-  });
+  const response = await deps.fetchClient.POST("/v1/user/change_password", { body: request });
   if (response.error || !response.data)
     throw response.error ?? new Error("Failed to change password");
-  await updateSigningPrivateKey(newSigningPrivateKey);
-  return {
-    newSigningPrivateKey,
-    workspacesUpdated: response.data.workspaces_updated ?? 0,
-    messagesReEncrypted
-  };
+  if (fromStore) await updateWrappedIdentityKey(request.wrapped_identity_key);
+  return { wrappedIdentityKey: request.wrapped_identity_key };
 }
 
 // src/client.ts
@@ -1370,7 +1271,8 @@ function createArbiClient(options) {
       return {
         accessToken: data.access_token,
         sessionKey: base64ToBytes(data.session_key),
-        userExtId: data.user.external_id ?? void 0
+        userExtId: data.user.external_id ?? void 0,
+        wrappedIdentityKey: data.wrapped_identity_key ?? null
       };
     }
   };
@@ -1517,6 +1419,6 @@ function isMessageType(msg, type) {
   return msg.type === type;
 }
 
-export { API_PREFIX, CALL_KEY_BYTES, base64Decode, base64Encode, base64ToBytes, buildCallFragment, buildWebSocketUrl, bytesToBase64, canPersistSession, changePasswordWithRekey, clearAllData, clearSession, computeSharedSecret, createArbiClient, createAuthMessage, createAutoReloginMiddleware, createBearerAuthMiddleware, createContentHash, createReloginHandler, createSessionManager, createWorkspaceReopener, decodeCallKey, decryptCallTitle, decryptFile, decryptMessage, decryptMessageWithSharedSecret, deriveEncryptionKeypairFromSigning, derivePublicKey, encodeCallKey, encryptCallTitle, encryptFile, encryptMessage, encryptMessageWithSharedSecret, generateCallKey, generateKeyPairs, generateLoginCredentials, generateLoginCredentialsFromKey, generatePasswordChangeCredentials, generateRandomSigningKeypair, generateRecoveryPasswordChangeCredentials, generateRegistrationCredentials, generateUserKeypairs, getSession, getUserEncryptionKeypair, hasSession, initSodium, initializeDatabase, isMessageType, openSealedCallKey, parseCallFragment, parseServerMessage, passwordChangeErrorMessage, prewarmKeyPairs, saveSession, sealCallKey, sealKeyForSession, sealedBoxDecrypt, sealedBoxEncrypt, signMessage, updateSigningPrivateKey };
+export { API_PREFIX, CALL_KEY_BYTES, base64Decode, base64Encode, base64ToBytes, buildCallFragment, buildWebSocketUrl, bytesToBase64, canPersistSession, changePassword, clearAllData, clearSession, computeSharedSecret, createArbiClient, createAuthMessage, createAutoReloginMiddleware, createBearerAuthMiddleware, createContentHash, createReloginHandler, createSessionManager, createWorkspaceReopener, decodeCallKey, decryptCallTitle, decryptFile, decryptMessage, decryptMessageWithSharedSecret, deriveEncryptionKeypairFromSigning, derivePublicKey, encodeCallKey, encryptCallTitle, encryptFile, encryptMessage, encryptMessageWithSharedSecret, generateCallKey, generateIdentityKeypair, generateKeyPairs, generateLoginCredentials, generateLoginCredentialsFromKey, generatePasswordChangeCredentials, generateRandomSigningKeypair, generateRegistrationCredentials, generateUserKeypairs, getSession, getUserEncryptionKeypair, hasSession, identityFromLoginResponse, initSodium, initializeDatabase, isMessageType, openSealedCallKey, parseCallFragment, parseServerMessage, passwordChangeErrorMessage, prewarmKeyPairs, saveSession, sealCallKey, sealKeyForSession, sealedBoxDecrypt, sealedBoxEncrypt, signMessage, unlockIdentityWithPassword, unwrapIdentityKey, updateWrappedIdentityKey, wrapIdentityKey };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map