@travelclw/proof-protocol 0.1.1 → 0.2.0

package/browser.js

@@ -1,267 +1,342 @@
-'use strict'
-
-const {
-  canonicalizeBody,
-  canonicalizeQuery,
-  isRequestProofRequired,
-  isRequestProofSetupError,
-  normalizePath,
-} = require('./core')
-
-const bytesToBase64Url = bytes => {
-  let binary = ''
-  bytes.forEach(byte => {
-    binary += String.fromCharCode(byte)
-  })
-  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '')
-}
-
-const textToBase64Url = value => bytesToBase64Url(new TextEncoder().encode(value))
-
-const getWebCrypto = () => {
-  const webCrypto = globalThis.crypto
-  if (!webCrypto?.subtle) throw new Error('request_proof_unsupported')
-  return webCrypto
-}
-
-const sha256Base64Url = async value => {
-  const digest = await getWebCrypto().subtle.digest('SHA-256', new TextEncoder().encode(value))
-  return bytesToBase64Url(new Uint8Array(digest))
-}
-
-const normalizePublicKey = publicKey => ({
-  kty: 'EC',
-  crv: 'P-256',
-  x: String(publicKey?.x || ''),
-  y: String(publicKey?.y || ''),
-})
-
-const calculateKeyId = publicKey =>
-  sha256Base64Url(
-    JSON.stringify({
-      crv: 'P-256',
-      kty: 'EC',
-      x: String(publicKey?.x || ''),
-      y: String(publicKey?.y || ''),
-    }),
-  )
-
-const createProofRequestId = () => {
-  const webCrypto = getWebCrypto()
-  return typeof webCrypto.randomUUID === 'function'
-    ? webCrypto.randomUUID()
-    : bytesToBase64Url(webCrypto.getRandomValues(new Uint8Array(24)))
-}
-
-const createBrowserProofClient = options => {
-  const databaseName = String(options?.databaseName || '').trim()
-  const storeName = String(options?.storeName || 'context').trim()
-  const recordId = String(options?.recordId || 'request-proof-key').trim()
-  const required = () => isRequestProofRequired(options?.required?.())
-  let proofKeyPromise = null
-  let resetPromise = null
-
-  if (!databaseName || !storeName || !recordId) {
-    throw new Error('request_proof_storage_failed')
-  }
-
-  const openDatabase = () =>
-    new Promise((resolve, reject) => {
-      if (!globalThis.indexedDB) {
-        reject(new Error('request_proof_storage_unsupported'))
-        return
-      }
-      const request = globalThis.indexedDB.open(databaseName, 1)
-      request.onupgradeneeded = () => {
-        const database = request.result
-        if (!database.objectStoreNames.contains(storeName)) {
-          database.createObjectStore(storeName, { keyPath: 'id' })
-        }
-      }
-      request.onsuccess = () => resolve(request.result)
-      request.onerror = () => reject(new Error('request_proof_storage_failed'))
-    })
-
-  const readStoredKey = async () => {
-    const database = await openDatabase()
-    try {
-      return await new Promise((resolve, reject) => {
-        const request = database.transaction(storeName, 'readonly').objectStore(storeName).get(recordId)
-        request.onsuccess = () => resolve(request.result || null)
-        request.onerror = () => reject(new Error('request_proof_read_failed'))
-      })
-    } finally {
-      database.close()
-    }
-  }
-
-  const isStoredKeyValid = record => {
-    if (!record?.keyId || !record.publicKey?.x || !record.publicKey?.y || !record.privateKey) return false
-    const algorithm = record.privateKey.algorithm
-    return (
-      record.privateKey.type === 'private' &&
-      record.privateKey.extractable === false &&
-      algorithm?.name === 'ECDSA' &&
-      algorithm?.namedCurve === 'P-256' &&
-      Array.isArray(record.privateKey.usages) &&
-      record.privateKey.usages.includes('sign')
-    )
-  }
-
-  const generateCandidate = async () => {
-    const webCrypto = getWebCrypto()
-    const keyPair = await webCrypto.subtle.generateKey(
-      { name: 'ECDSA', namedCurve: 'P-256' },
-      false,
-      ['sign', 'verify'],
-    )
-    const publicKey = normalizePublicKey(await webCrypto.subtle.exportKey('jwk', keyPair.publicKey))
-    return {
-      id: recordId,
-      keyId: await calculateKeyId(publicKey),
-      publicKey,
-      privateKey: keyPair.privateKey,
-      createdAt: new Date().toISOString(),
-    }
-  }
-
-  const storeIfAbsent = async candidate => {
-    const database = await openDatabase()
-    let selectedKey = candidate
-    try {
-      await new Promise((resolve, reject) => {
-        const transaction = database.transaction(storeName, 'readwrite')
-        const store = transaction.objectStore(storeName)
-        const readRequest = store.get(recordId)
-        readRequest.onsuccess = () => {
-          const storedKey = readRequest.result || null
-          if (isStoredKeyValid(storedKey)) selectedKey = storedKey
-          else store.put(candidate)
-        }
-        readRequest.onerror = () => reject(new Error('request_proof_read_failed'))
-        transaction.oncomplete = () => resolve()
-        transaction.onerror = () => reject(new Error('request_proof_write_failed'))
-        transaction.onabort = () => reject(new Error('request_proof_write_failed'))
-      })
-      return selectedKey
-    } finally {
-      database.close()
-    }
-  }
-
-  const getOrCreateKey = () => {
-    if (!proofKeyPromise) {
-      const pendingReset = resetPromise
-      proofKeyPromise = (async () => {
-        await pendingReset
-        const storedKey = await readStoredKey()
-        if (isStoredKeyValid(storedKey)) return storedKey
-        return storeIfAbsent(await generateCandidate())
-      })().catch(error => {
-        proofKeyPromise = null
-        throw error
-      })
-    }
-    return proofKeyPromise
-  }
-
-  const reset = () => {
-    const pendingReset = resetPromise
-    const operation = (async () => {
-      const pendingKey = proofKeyPromise
-      proofKeyPromise = null
-      await pendingReset?.catch(() => undefined)
-      await pendingKey?.catch(() => undefined)
-      if (!globalThis.indexedDB) return
-
-      const database = await openDatabase()
-      try {
-        await new Promise((resolve, reject) => {
-          const transaction = database.transaction(storeName, 'readwrite')
-          transaction.objectStore(storeName).delete(recordId)
-          transaction.oncomplete = () => resolve()
-          transaction.onerror = () => reject(new Error('request_proof_reset_failed'))
-          transaction.onabort = () => reject(new Error('request_proof_reset_failed'))
-        })
-      } finally {
-        database.close()
-      }
-    })()
-
-    resetPromise = operation
-    return operation.finally(() => {
-      if (resetPromise === operation) resetPromise = null
-    })
-  }
-
-  const getRegistration = async () => {
-    const key = await getOrCreateKey()
-    return { keyId: key.keyId, publicKey: key.publicKey }
-  }
-
-  const runtimeUnavailable = () =>
-    (typeof window !== 'undefined' && window.isSecureContext === false) ||
-    !globalThis.crypto?.subtle ||
-    !globalThis.indexedDB
-
-  const tryGetRegistration = async () => {
-    if (!required() && runtimeUnavailable()) return null
-    try {
-      return await getRegistration()
-    } catch (error) {
-      if (!required() && isRequestProofSetupError(error)) return null
-      throw error
-    }
-  }
-
-  const createProof = async input => {
-    const token = String(input?.token || '').trim()
-    if (!token) return ''
-    const key = await getOrCreateKey()
-    const requestId = String(input?.requestId || '').trim()
-    const [ath, qsh, bth] = await Promise.all([
-      sha256Base64Url(token),
-      sha256Base64Url(canonicalizeQuery(input?.requestUri)),
-      sha256Base64Url(canonicalizeBody(input?.body, input?.contentType, input?.hasBody)),
-    ])
-    const header = { alg: 'ES256', kid: key.keyId, typ: 'dpop+jwt' }
-    const payload = {
-      ath,
-      aud: String(input?.audience || ''),
-      htm: String(input?.method || 'GET').toUpperCase(),
-      htu: normalizePath(input?.path),
-      qsh,
-      bth,
-      rid: requestId,
-      iat: Math.floor(Date.now() / 1000),
-      jti: createProofRequestId(),
-    }
-    const signingInput = `${textToBase64Url(JSON.stringify(header))}.${textToBase64Url(JSON.stringify(payload))}`
-    let signature
-    try {
-      signature = await getWebCrypto().subtle.sign(
-        { name: 'ECDSA', hash: 'SHA-256' },
-        key.privateKey,
-        new TextEncoder().encode(signingInput),
-      )
-    } catch {
-      throw new Error('request_proof_sign_failed')
-    }
-    return `${signingInput}.${bytesToBase64Url(new Uint8Array(signature))}`
-  }
-
-  const tryCreateProof = async input => {
-    if (!String(input?.token || '').trim()) return ''
-    if (!required() && runtimeUnavailable()) return ''
-    try {
-      return await createProof(input)
-    } catch (error) {
-      if (!required() && isRequestProofSetupError(error)) return ''
-      throw error
-    }
-  }
-
-  return { createProof, getRegistration, reset, tryCreateProof, tryGetRegistration }
-}
-
-module.exports = { calculateKeyId, createBrowserProofClient, createProofRequestId }
+'use strict'
+
+const {
+  canonicalizeBody,
+  canonicalizeQuery,
+  isRequestProofRequired,
+  isRequestProofSetupError,
+  normalizePath,
+} = require('./core')
+
+const bytesToBase64Url = bytes => {
+  let binary = ''
+  bytes.forEach(byte => {
+    binary += String.fromCharCode(byte)
+  })
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '')
+}
+
+const textToBase64Url = value => bytesToBase64Url(new TextEncoder().encode(value))
+
+const getWebCrypto = () => {
+  const webCrypto = globalThis.crypto
+  if (!webCrypto?.subtle) throw new Error('request_proof_unsupported')
+  return webCrypto
+}
+
+const sha256Base64Url = async value => {
+  const digest = await getWebCrypto().subtle.digest('SHA-256', new TextEncoder().encode(value))
+  return bytesToBase64Url(new Uint8Array(digest))
+}
+
+const normalizePublicKey = publicKey => ({
+  kty: 'EC',
+  crv: 'P-256',
+  x: String(publicKey?.x || ''),
+  y: String(publicKey?.y || ''),
+})
+
+const calculateKeyId = publicKey =>
+  sha256Base64Url(
+    JSON.stringify({
+      crv: 'P-256',
+      kty: 'EC',
+      x: String(publicKey?.x || ''),
+      y: String(publicKey?.y || ''),
+    }),
+  )
+
+const createProofRequestId = () => {
+  const webCrypto = getWebCrypto()
+  return typeof webCrypto.randomUUID === 'function'
+    ? webCrypto.randomUUID()
+    : bytesToBase64Url(webCrypto.getRandomValues(new Uint8Array(24)))
+}
+
+const createBrowserProofClient = options => {
+  const databaseName = String(options?.databaseName || '').trim()
+  const storeName = String(options?.storeName || 'context').trim()
+  const recordId = String(options?.recordId || 'request-proof-key').trim()
+  const required = () => isRequestProofRequired(options?.required?.())
+  let proofKeyPromise = null
+  let resetPromise = null
+  let resetChannel = null
+
+  if (!databaseName || !storeName || !recordId) {
+    throw new Error('request_proof_storage_failed')
+  }
+
+  const openDatabase = () =>
+    new Promise((resolve, reject) => {
+      if (!globalThis.indexedDB) {
+        reject(new Error('request_proof_storage_unsupported'))
+        return
+      }
+      const request = globalThis.indexedDB.open(databaseName, 1)
+      request.onupgradeneeded = () => {
+        const database = request.result
+        if (!database.objectStoreNames.contains(storeName)) {
+          database.createObjectStore(storeName, { keyPath: 'id' })
+        }
+      }
+      request.onsuccess = () => resolve(request.result)
+      request.onerror = () => reject(new Error('request_proof_storage_failed'))
+    })
+
+  const readStoredKey = async () => {
+    const database = await openDatabase()
+    try {
+      return await new Promise((resolve, reject) => {
+        const request = database.transaction(storeName, 'readonly').objectStore(storeName).get(recordId)
+        request.onsuccess = () => resolve(request.result || null)
+        request.onerror = () => reject(new Error('request_proof_read_failed'))
+      })
+    } finally {
+      database.close()
+    }
+  }
+
+  const isStoredKeyValid = record => {
+    if (!record?.keyId || !record.publicKey?.x || !record.publicKey?.y || !record.privateKey) return false
+    const algorithm = record.privateKey.algorithm
+    return (
+      record.privateKey.type === 'private' &&
+      record.privateKey.extractable === false &&
+      algorithm?.name === 'ECDSA' &&
+      algorithm?.namedCurve === 'P-256' &&
+      Array.isArray(record.privateKey.usages) &&
+      record.privateKey.usages.includes('sign')
+    )
+  }
+
+  const generateCandidate = async () => {
+    const webCrypto = getWebCrypto()
+    const keyPair = await webCrypto.subtle.generateKey(
+      { name: 'ECDSA', namedCurve: 'P-256' },
+      false,
+      ['sign', 'verify'],
+    )
+    const publicKey = normalizePublicKey(await webCrypto.subtle.exportKey('jwk', keyPair.publicKey))
+    return {
+      id: recordId,
+      keyId: await calculateKeyId(publicKey),
+      publicKey,
+      privateKey: keyPair.privateKey,
+      createdAt: new Date().toISOString(),
+    }
+  }
+
+  const storeIfAbsent = async candidate => {
+    const database = await openDatabase()
+    let selectedKey = candidate
+    try {
+      await new Promise((resolve, reject) => {
+        const transaction = database.transaction(storeName, 'readwrite')
+        const store = transaction.objectStore(storeName)
+        const readRequest = store.get(recordId)
+        readRequest.onsuccess = () => {
+          const storedKey = readRequest.result || null
+          if (isStoredKeyValid(storedKey)) selectedKey = storedKey
+          else store.put(candidate)
+        }
+        readRequest.onerror = () => reject(new Error('request_proof_read_failed'))
+        transaction.oncomplete = () => resolve()
+        transaction.onerror = () => reject(new Error('request_proof_write_failed'))
+        transaction.onabort = () => reject(new Error('request_proof_write_failed'))
+      })
+      return selectedKey
+    } finally {
+      database.close()
+    }
+  }
+
+  const getResetChannelName = () =>
+    `@travelclw/proof-protocol/reset/${databaseName}/${storeName}/${recordId}`
+
+  const invalidateLocalKey = () => {
+    proofKeyPromise = null
+  }
+
+  if (typeof globalThis.BroadcastChannel === 'function') {
+    try {
+      resetChannel = new globalThis.BroadcastChannel(getResetChannelName())
+      resetChannel.onmessage = event => {
+        if (event?.data?.type === 'request-proof-reset') invalidateLocalKey()
+      }
+      if (typeof resetChannel.unref === 'function') resetChannel.unref()
+    } catch {
+      resetChannel = null
+    }
+  }
+
+  const broadcastReset = () => {
+    try {
+      resetChannel?.postMessage({ type: 'request-proof-reset' })
+    } catch {
+      // IndexedDB verification below remains authoritative when the channel is unavailable.
+    }
+  }
+
+  const getOrCreateKey = () => {
+    if (!proofKeyPromise) {
+      const pendingReset = resetPromise
+      const operation = (async () => {
+        await pendingReset
+        const storedKey = await readStoredKey()
+        if (isStoredKeyValid(storedKey)) return storedKey
+        return storeIfAbsent(await generateCandidate())
+      })()
+      const pendingKey = operation.finally(() => {
+        if (proofKeyPromise === pendingKey) proofKeyPromise = null
+      })
+      proofKeyPromise = pendingKey
+    }
+    return proofKeyPromise
+  }
+
+  const getCurrentKey = async () => {
+    while (true) {
+      const key = await getOrCreateKey()
+      const storedKey = await readStoredKey()
+      if (isStoredKeyValid(storedKey) && storedKey.keyId === key.keyId) return storedKey
+      invalidateLocalKey()
+    }
+  }
+
+  const reset = () => {
+    const pendingReset = resetPromise
+    const operation = (async () => {
+      broadcastReset()
+      const pendingKey = proofKeyPromise
+      invalidateLocalKey()
+      await pendingReset?.catch(() => undefined)
+      await pendingKey?.catch(() => undefined)
+      if (!globalThis.indexedDB) return
+
+      const database = await openDatabase()
+      try {
+        await new Promise((resolve, reject) => {
+          const transaction = database.transaction(storeName, 'readwrite')
+          transaction.objectStore(storeName).delete(recordId)
+          transaction.oncomplete = () => resolve()
+          transaction.onerror = () => reject(new Error('request_proof_reset_failed'))
+          transaction.onabort = () => reject(new Error('request_proof_reset_failed'))
+        })
+      } finally {
+        database.close()
+      }
+    })()
+
+    resetPromise = operation
+    return operation.finally(() => {
+      if (resetPromise === operation) resetPromise = null
+    })
+  }
+
+  const getRegistration = async () => {
+    const key = await getCurrentKey()
+    return { keyId: key.keyId, publicKey: key.publicKey }
+  }
+
+  const runtimeUnavailable = () =>
+    (typeof window !== 'undefined' && window.isSecureContext === false) ||
+    !globalThis.crypto?.subtle ||
+    !globalThis.indexedDB
+
+  const tryGetRegistration = async () => {
+    if (!required() && runtimeUnavailable()) return null
+    try {
+      return await getRegistration()
+    } catch (error) {
+      if (!required() && isRequestProofSetupError(error)) return null
+      throw error
+    }
+  }
+
+  const createContextProof = async input => {
+    if (!['session', 'ticket'].includes(input.purpose)) throw new Error('request_proof_context_invalid')
+    const key = await readStoredKey()
+    if (!isStoredKeyValid(key) || resetPromise) throw new Error('request_proof_key_missing')
+    if (input.purpose === 'ticket' && key.keyId !== input.expectedKeyId) {
+      throw new Error('request_proof_key_changed')
+    }
+    let binding
+    if (input.purpose === 'session') {
+      try {
+        const header = JSON.parse(atob(String(input.token).split('.')[0].replace(/-/g, '+').replace(/_/g, '/')))
+        if (typeof header.psid !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(header.psid)) throw new Error('missing')
+        binding = { psid: header.psid }
+      } catch { throw new Error('request_proof_session_missing') }
+    } else {
+      if (!input.token) throw new Error('request_proof_context_invalid')
+      binding = { sth: await sha256Base64Url(input.token) }
+    }
+    const header = { alg: 'ES256', kid: key.keyId, typ: 'ctx-proof+jwt' }
+    const payload = {
+      ver: 2, purpose: input.purpose, ...binding,
+      aud: input.audience, htm: String(input.method).toUpperCase(), htu: normalizePath(input.path),
+      iat: Math.floor(Date.now() / 1000), jti: createProofRequestId(),
+    }
+    const signingInput = `${textToBase64Url(JSON.stringify(header))}.${textToBase64Url(JSON.stringify(payload))}`
+    const signature = await getWebCrypto().subtle.sign(
+      { name: 'ECDSA', hash: 'SHA-256' }, key.privateKey, new TextEncoder().encode(signingInput),
+    )
+    const current = await readStoredKey()
+    if (resetPromise || !isStoredKeyValid(current) || current.keyId !== key.keyId) {
+      throw new Error('request_proof_key_changed')
+    }
+    return `${signingInput}.${bytesToBase64Url(new Uint8Array(signature))}`
+  }
+
+  const createProof = async input => {
+    if (input?.purpose) return createContextProof(input)
+    const token = String(input?.token || '').trim()
+    if (!token) return ''
+    const requestId = String(input?.requestId || '').trim()
+    const [ath, qsh, bth] = await Promise.all([
+      sha256Base64Url(token),
+      sha256Base64Url(canonicalizeQuery(input?.requestUri)),
+      sha256Base64Url(canonicalizeBody(input?.body, input?.contentType, input?.hasBody)),
+    ])
+    const key = await getCurrentKey()
+    const header = { alg: 'ES256', kid: key.keyId, typ: 'dpop+jwt' }
+    const payload = {
+      ath,
+      aud: String(input?.audience || ''),
+      htm: String(input?.method || 'GET').toUpperCase(),
+      htu: normalizePath(input?.path),
+      qsh,
+      bth,
+      rid: requestId,
+      iat: Math.floor(Date.now() / 1000),
+      jti: createProofRequestId(),
+    }
+    const signingInput = `${textToBase64Url(JSON.stringify(header))}.${textToBase64Url(JSON.stringify(payload))}`
+    let signature
+    try {
+      signature = await getWebCrypto().subtle.sign(
+        { name: 'ECDSA', hash: 'SHA-256' },
+        key.privateKey,
+        new TextEncoder().encode(signingInput),
+      )
+    } catch {
+      throw new Error('request_proof_sign_failed')
+    }
+    return `${signingInput}.${bytesToBase64Url(new Uint8Array(signature))}`
+  }
+
+  const tryCreateProof = async input => {
+    if (!String(input?.token || '').trim()) return ''
+    if (!input?.purpose && !required() && runtimeUnavailable()) return ''
+    try {
+      return await createProof(input)
+    } catch (error) {
+      if (!input?.purpose && !required() && isRequestProofSetupError(error)) return ''
+      throw error
+    }
+  }
+
+  return { createProof, getRegistration, reset, tryCreateProof, tryGetRegistration }
+}
+
+module.exports = { calculateKeyId, createBrowserProofClient, createProofRequestId }