@calimero-network/mero-js 26.2.0 → 26.2.2

package/dist/index.mjs

@@ -2535,6 +2535,9 @@ var STATE_PARAM = "link_state";
 var LIFETIME_MS = 10 * 60 * 1e3;
 var ACCOUNT_HEX = /^[0-9a-f]{64}$/;
 var MAX_PENDING = 20;
+var VERIFIER_BYTES = 32;
+var VERIFIER_HEX = /^[0-9a-f]{64}$/;
+var LINK_GRANT_USE = "account-link-grant";
 function readPending(key, now) {
   try {
     const raw = localStorage.getItem(key);
@@ -2557,10 +2560,7 @@ function writePending(key, pending) {
 function beginState(key, payload) {
   const now = Date.now();
   const pending = readPending(key, now);
-  const bytes = crypto.getRandomValues(new Uint8Array(16));
-  const state = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
-    ""
-  );
+  const state = hex(crypto.getRandomValues(new Uint8Array(16)));
   pending[state] = { ...payload, expiresAt: now + LIFETIME_MS };
   writePending(key, Object.fromEntries(Object.entries(pending).slice(-MAX_PENDING)));
   return state;
@@ -2574,16 +2574,41 @@ function takeState(key, state) {
   writePending(key, pending);
   return entry;
 }
-function beginLinkState(account, returnTo) {
+async function linkChallenge(verifier) {
+  const bytes = Uint8Array.from(verifier.match(/../g) ?? [], (b) => parseInt(b, 16));
+  return hex(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)));
+}
+async function beginLinkState(account, returnTo) {
   if (!ACCOUNT_HEX.test(account)) {
     throw new Error("accountId must be 64 lowercase hex characters");
   }
   const url2 = new URL(returnTo);
-  url2.searchParams.set(STATE_PARAM, beginState(KEY, { account }));
-  return url2.toString();
+  const verifier = hex(crypto.getRandomValues(new Uint8Array(VERIFIER_BYTES)));
+  const challenge = await linkChallenge(verifier);
+  url2.searchParams.set(STATE_PARAM, beginState(KEY, { account, verifier }));
+  return { callbackUrl: url2.toString(), challenge };
+}
+function takeLinkVerifier(search, account) {
+  const pending = takeState(
+    KEY,
+    new URLSearchParams(search).get(STATE_PARAM)
+  );
+  if (!pending || pending.account !== account) return null;
+  return typeof pending.verifier === "string" && VERIFIER_HEX.test(pending.verifier) ? pending.verifier : null;
 }
-function takeLinkState(search) {
-  return takeState(KEY, new URLSearchParams(search).get(STATE_PARAM));
+function linkGrantClaims(grant) {
+  try {
+    const body = grant.split(".")[0].replace(/-/g, "+").replace(/_/g, "/");
+    const claims = JSON.parse(
+      new TextDecoder().decode(Uint8Array.from(atob(body), (c) => c.charCodeAt(0)))
+    );
+    const { use, sub, acc, chal } = claims;
+    if (use !== LINK_GRANT_USE) return null;
+    if (typeof sub !== "string" || typeof acc !== "string" || typeof chal !== "string") return null;
+    return { login: sub, account: acc, challenge: chal };
+  } catch {
+    return null;
+  }
 }
 function withoutLinkState(search) {
   const params = new URLSearchParams(search);
@@ -9801,21 +9826,23 @@ function base643(bytes) {
 
 // src/cloud/link-redirect.ts
 var DEFAULT_CLOUD_WEB_URL = "https://cloud.calimero.network";
-function cloudLinkUrl(options) {
+async function cloudLinkUrl(options) {
   const url2 = new URL(options.cloudWebUrl ?? DEFAULT_CLOUD_WEB_URL);
+  const { callbackUrl, challenge } = await beginLinkState(options.accountId, options.returnTo);
   url2.searchParams.set("link-account", options.accountId);
-  url2.searchParams.set("callback-url", beginLinkState(options.accountId, options.returnTo));
+  url2.searchParams.set("challenge", challenge);
+  url2.searchParams.set("callback-url", callbackUrl);
   return url2.toString();
 }
-function beginCloudLink(options) {
-  window.location.assign(cloudLinkUrl(options));
+async function beginCloudLink(options) {
+  window.location.assign(await cloudLinkUrl(options));
   throw new Error("redirecting to the cloud to authorise this link");
 }
 function readCloudLinkCallback(location2 = window.location) {
   const params = new URLSearchParams(location2.hash.replace(/^#/, ""));
   const error = params.get("error");
   if (error) {
-    takeLinkState(location2.search ?? "");
+    takeLinkVerifier(location2.search ?? "", null);
     stripFragment();
     throw new Error(
       error === "denied" ? "the account link was declined at the cloud" : `the cloud refused this link: ${error}`
@@ -9824,14 +9851,16 @@ function readCloudLinkCallback(location2 = window.location) {
   const grant = params.get("grant");
   const account = params.get("account");
   if (!grant || !account) return null;
-  if (takeLinkState(location2.search ?? "")?.account !== account) {
+  const verifier = takeLinkVerifier(location2.search ?? "", account);
+  const claims = linkGrantClaims(grant);
+  if (!verifier || claims?.account !== account) {
     stripFragment();
     throw new Error(
       "this account link answers a request this browser did not make - start the link again from here"
     );
   }
   stripFragment();
-  return { grant, account };
+  return { grant, account, login: claims.login, verifier };
 }
 function stripFragment() {
   if (typeof history === "undefined" || !history.replaceState) return;
@@ -9848,7 +9877,11 @@ async function completeCloudLink(options) {
     cloudBaseUrl: options.cloudBaseUrl,
     fetch: options.fetch
   });
-  return cloud.linkAccountWithGrant({ grant: options.grant, signer: root.signer });
+  return cloud.linkAccountWithGrant({
+    grant: options.grant,
+    verifier: options.verifier,
+    signer: root.signer
+  });
 }
 
 // src/cloud/enrol-redirect.ts
@@ -10142,7 +10175,7 @@ function bytes32(value, label2) {
 }
 
 // src/namespace-op/namespace-op.ts
-var SIGNED_NAMESPACE_OP_SCHEMA_VERSION = 25;
+var SIGNED_NAMESPACE_OP_SCHEMA_VERSION = 26;
 var NAMESPACE_SIGN_DOMAIN = new TextEncoder().encode("calimero.namespace.v1");
 var NAMESPACE_OP_ROOT = 0;
 var ROOT_OP2 = {
@@ -11692,11 +11725,13 @@ var CloudClient = class {
    * Static, so it needs no client and no session: there is nothing to
    * authenticate as yet.
    */
-  static accountLinkHandoff(options) {
+  static async accountLinkHandoff(options) {
     const portal = options.portalUrl.replace(/\/+$/, "");
+    const { callbackUrl, challenge } = await beginLinkState(options.accountId, options.callbackUrl);
     const query = new URLSearchParams({
       "link-account": options.accountId,
-      "callback-url": beginLinkState(options.accountId, options.callbackUrl)
+      challenge,
+      "callback-url": callbackUrl
     });
     return { url: `${portal}/?${query.toString()}`, accountId: options.accountId };
   }
@@ -11727,11 +11762,15 @@ var CloudClient = class {
     const accountId = params.get("account");
     const error = params.get("error");
     const out = {};
-    if (error) takeLinkState(search);
-    if (grant && takeLinkState(search)?.account !== accountId) {
-      return { error: "unexpected_callback" };
+    if (error) takeLinkVerifier(search, null);
+    if (grant) {
+      const verifier = takeLinkVerifier(search, accountId);
+      const claims = linkGrantClaims(grant);
+      if (!verifier || claims?.account !== accountId) return { error: "unexpected_callback" };
+      out.grant = grant;
+      out.login = claims.login;
+      out.verifier = verifier;
     }
-    if (grant) out.grant = grant;
     if (accountId) out.accountId = accountId;
     if (error) out.error = error;
     return out;
@@ -11746,24 +11785,40 @@ var CloudClient = class {
    *
    * The signature is an ordinary account-link signature with the grant as the
    * nonce, so the same {@link signAccountLink} every other link path uses signs
-   * this one. Both halves are required: a grant without the key links nothing,
-   * which is what makes it safe to carry through a browser redirect.
+   * this one. The grant is bound to the verifier of the browser that asked for
+   * it, and is refused here, before the root signs, unless it carries that
+   * verifier's challenge and names this root's account.
    *
    * A `403` means the grant was bad, expired, already spent, or signed by a key
    * that names a different account; `409` that the account belongs to another
    * login; `402` that the plan is full.
    */
   async linkAccountWithGrant(options) {
+    if (typeof options.verifier !== "string" || !VERIFIER_HEX.test(options.verifier)) {
+      throw new Error("no verifier for this grant - start the link again from this browser");
+    }
+    const claims = linkGrantClaims(options.grant);
+    if (claims?.challenge !== await linkChallenge(options.verifier)) {
+      throw new Error(
+        "this grant was not issued to this link request - start the link again from this browser"
+      );
+    }
     const { signer, publicKey, accountId } = await resolveRootPair(
       options.rootSecret,
       options.signer
     );
+    if (claims.account !== accountId) {
+      throw new Error(
+        `this grant is for account ${claims.account}, but the root here derives ${accountId} - it was minted for a different account`
+      );
+    }
     const body = await this.request(
       "POST",
       "/api/cloud/accounts/link",
       {
         body: {
           grant: options.grant,
+          verifier: options.verifier,
           root_public_key: publicKey,
           signature: await signAccountLink({
             signer,