@pulse-compute/crypto 1.0.0-beta.4 → 1.0.0-beta.6

package/src/provider.cjs

@@ -19,7 +19,7 @@ function bindJavascriptDigestMac(algorithms, subtle = globalThis.crypto && globa
     || algorithms.includes('HMAC-SHA256') && (typeof subtle.sign !== 'function' || typeof subtle.importKey !== 'function')) throw new TypeError('Selected Web Crypto byte realization is unavailable.');
   const bytes = {};
   if (algorithms.includes('SHA-256')) bytes.sha256 = async (input) => {
-    const data = snapshot(input, 32768);
+    const data = snapshot(input, 2097152);
     try { return result(await subtle.digest({ name: 'SHA-256' }, data)); }
     finally { data.fill(0); }
   };
@@ -40,4 +40,143 @@ function bindJavascriptDigestMac(algorithms, subtle = globalThis.crypto && globa
     algorithms: Object.freeze(algorithms.map((algorithm) => Object.freeze({ algorithm, realization: 'runtime-builtin', implementation: IMPLEMENTATIONS[algorithm], available: true, automaticFallback: false })))
   }) });
 }
-module.exports = Object.freeze({ IMPLEMENTATIONS, bindJavascriptDigestMac });
+const DIGEST_TEXT_MAX_BYTES = 2097152;
+const digestFailures = Object.freeze(Object.fromEntries(
+  ['invalid-text', 'too-large', 'unavailable', 'realization-failure'].map(reason => [reason, Object.freeze({ status: 'failed', reason })])
+));
+// Count scalar UTF-8 bytes before allocating staging; do not replace surrogates.
+function textDigestByteLength(text) {
+  if (typeof text !== 'string') return -1;
+  if (text.length > DIGEST_TEXT_MAX_BYTES) return -2;
+  let bytes = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff) {
+      const low = text.charCodeAt(++i);
+      if (!(low >= 0xdc00 && low <= 0xdfff)) return -1;
+      bytes += 4;
+    } else if (c >= 0xdc00 && c <= 0xdfff) return -1;
+    else bytes += c < 0x80 ? 1 : c < 0x800 ? 2 : 3;
+  }
+  return bytes > DIGEST_TEXT_MAX_BYTES ? -2 : bytes;
+}
+function normalizeTextDigestResult(value) {
+  const failed = digestFailures['realization-failure'];
+  if (!value || typeof value !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return failed;
+  const properties = Object.getOwnPropertyDescriptors(value), keys = Reflect.ownKeys(properties);
+  if (keys.some(key => typeof key !== 'string' || !properties[key].enumerable || !Object.hasOwn(properties[key], 'value'))) return failed;
+  const status = properties.status?.value, reason = properties.reason?.value;
+  if (status === 'failed' && keys.length === 2 && typeof reason === 'string' && Object.hasOwn(digestFailures, reason)) return digestFailures[reason];
+  const sha256 = properties.sha256?.value, byteLength = properties.byteLength?.value;
+  if (status !== 'ok' || keys.length !== 3 || typeof sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(sha256)
+    || !Number.isInteger(byteLength) || byteLength < 0 || byteLength > DIGEST_TEXT_MAX_BYTES) return failed;
+  return Object.freeze({ status: 'ok', sha256, byteLength });
+}
+function checkDigestCancellation(signal) {
+  if (signal?.aborted) throw signal.reason || new Error('Pulse digest invocation cancelled.');
+}
+async function executeTextDigest(effect, options = {}) {
+  if (!effect || effect.package !== '@pulse-compute/crypto' || effect.contractId !== 'pulse.crypto'
+    || effect.providerKind !== 'crypto' || effect.operation !== 'digestText'
+    || effect.kind !== 'crypto.digestText' || effect.capability !== 'crypto.digestText') throw new TypeError('Invalid Crypto digest effect authority.');
+  checkDigestCancellation(options.signal);
+  const text = effect.payload?.text, byteLength = textDigestByteLength(text);
+  if (byteLength < 0) return digestFailures[byteLength === -1 ? 'invalid-text' : 'too-large'];
+  const realization = options.cryptoTarget === 'javascript' ? 'runtime-builtin' : 'guest-source:pulse-hmac-as';
+  const bytes = options.cryptoVerifier?.bytes, algorithms = options.cryptoRealization?.algorithms;
+  if (typeof bytes?.sha256 !== 'function' || !Array.isArray(algorithms)
+    || !algorithms.some(entry => entry.algorithm === 'SHA-256' && entry.available === true && entry.realization === realization)) return digestFailures.unavailable;
+  const data = new TextEncoder().encode(text);
+  let digest;
+  try {
+    digest = await bytes.sha256(data);
+    checkDigestCancellation(options.signal);
+    if (!(digest instanceof Uint8Array) || digest.length !== 32) return digestFailures['realization-failure'];
+    const sha256 = Array.from(digest, byte => byte.toString(16).padStart(2, '0')).join('');
+    return Object.freeze({ status: 'ok', sha256, byteLength });
+  } catch (error) {
+    checkDigestCancellation(options.signal);
+    return digestFailures['realization-failure'];
+  } finally { data.fill(0); if (digest instanceof Uint8Array) digest.fill(0); }
+}
+function createJavascriptTextDigest(options = {}) {
+  return (effect, execution = {}) => {
+    let selected;
+    try { selected = bindJavascriptDigestMac(['SHA-256'], options.digestSubtle === undefined ? globalThis.crypto?.subtle : options.digestSubtle); }
+    catch { selected = undefined; }
+    return executeTextDigest(effect, { signal: execution.signal, cryptoTarget: 'javascript',
+      cryptoVerifier: selected, cryptoRealization: selected?.realization });
+  };
+}
+
+function bindJavascriptEs256Signer(subtle = globalThis.crypto?.subtle) {
+  if (!subtle || typeof subtle.importKey !== 'function' || typeof subtle.sign !== 'function'
+    || typeof subtle.verify !== 'function') throw new TypeError('Selected ES256 signing realization is unavailable.');
+  const encode = bytes => {
+    let binary = ''; for (const byte of bytes) binary += String.fromCharCode(byte);
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+  };
+  const invalidKey = () => Object.assign(new TypeError('Invalid P-256 signing key.'), { code: 'PULSE_CRYPTO_KEY_INVALID' });
+  return Object.freeze({ bytes: Object.freeze({ async es256Sign(key, data) {
+    if (!(key instanceof Uint8Array) || key.length !== 96) throw invalidKey();
+    if (!(data instanceof Uint8Array) || data.length > 16340) throw new TypeError('ES256 input exceeds its byte contract.');
+    const jwk = { kty: 'EC', crv: 'P-256', x: encode(key.subarray(0, 32)), y: encode(key.subarray(32, 64)), d: encode(key.subarray(64)) };
+    let signingKey, verifyingKey;
+    try {
+      signingKey = await subtle.importKey('jwk', jwk, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']);
+      verifyingKey = await subtle.importKey('jwk', { kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y },
+        { name: 'ECDSA', namedCurve: 'P-256' }, false, ['verify']);
+    } catch { throw invalidKey(); }
+    const signature = new Uint8Array(await subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, signingKey, data));
+    try {
+      if (signature.length !== 64 || !await subtle.verify({ name: 'ECDSA', hash: 'SHA-256' }, verifyingKey, signature, data)) {
+        throw invalidKey();
+      }
+      return signature.slice();
+    } finally { signature.fill(0); }
+  } }) });
+}
+
+// Metadata parsing remains JWT-owned. This adapter normalizes only RSA integers.
+async function rsaPrivateKeyBytes(components) {
+  return (await import('../dist/internal/rsa.js')).rsaKeyBytes(components, true);
+}
+function bindJavascriptRs256Signer(subtle = globalThis.crypto?.subtle) {
+  if (!subtle || typeof subtle.importKey !== 'function' || typeof subtle.sign !== 'function'
+    || typeof subtle.verify !== 'function') throw new TypeError('Selected RS256 signing realization is unavailable.');
+  const invalidKey = () => Object.assign(new TypeError('Invalid RSA signing key.'), { code: 'PULSE_CRYPTO_KEY_INVALID' });
+  return Object.freeze({ bytes: Object.freeze({ async rs256Sign(key, data) {
+    const { rsaWireJwk, RSA_DATA_BYTES_MAXIMUM } = await import('../dist/internal/rsa.js');
+    if (!(data instanceof Uint8Array) || data.length > RSA_DATA_BYTES_MAXIMUM) throw new TypeError('RS256 input exceeds its byte contract.');
+    let jwk, signingKey, verifyingKey;
+    const algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' };
+    try {
+      jwk = rsaWireJwk(key, true);
+      // Web Crypto implementations need not check every redundant CRT field.
+      // Check consistency explicitly at import. JavaScript BigInt has no
+      // constant-time guarantee; private exponentiation remains Web Crypto.
+      const integer = text => {
+        const binary = atob(text.replace(/-/g, '+').replace(/_/g, '/'));
+        let value = 0n; for (const byte of binary) value = value * 256n + BigInt(byte.charCodeAt(0));
+        return value;
+      };
+      const { n, e, d, p, q, dp, dq, qi } = Object.fromEntries(['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi'].map(name => [name, integer(jwk[name])]));
+      const k = key.length > 8 ? new DataView(key.buffer, key.byteOffset, 4).getUint32(0, true) : 0;
+      const halfMinimum = 1n << BigInt(k * 4 - 1);
+      if (p < halfMinimum || q < halfMinimum || !(p & q & 1n) || p === q || p*q !== n
+        || d <= 0n || d >= n || d % (p-1n) !== dp || d % (q-1n) !== dq
+        || e*dp % (p-1n) !== 1n || e*dq % (q-1n) !== 1n || qi <= 0n || qi >= p || q*qi % p !== 1n) throw invalidKey();
+      signingKey = await subtle.importKey('jwk', jwk, algorithm, false, ['sign']);
+      verifyingKey = await subtle.importKey('jwk', { kty: 'RSA', n: jwk.n, e: jwk.e }, algorithm, false, ['verify']);
+    } catch { throw invalidKey(); }
+    const signature = new Uint8Array(await subtle.sign(algorithm, signingKey, data));
+    try {
+      if (signature.length !== new DataView(key.buffer, key.byteOffset, 4).getUint32(0, true)
+        || !await subtle.verify(algorithm, verifyingKey, signature, data)) throw invalidKey();
+      return signature.slice();
+    } finally { signature.fill(0); }
+  } }) });
+}
+
+module.exports = Object.freeze({ rsaPrivateKeyBytes, bindJavascriptRs256Signer, bindJavascriptEs256Signer, IMPLEMENTATIONS, bindJavascriptDigestMac, DIGEST_TEXT_MAX_BYTES,
+  textDigestByteLength, normalizeTextDigestResult, executeTextDigest, createJavascriptTextDigest });

package/src/provider.d.cts

@@ -0,0 +1,6 @@
+import type { TextDigestResult } from './digest.js';
+export declare function normalizeTextDigestResult(value: unknown): TextDigestResult;
+declare const provider: { rsaPrivateKeyBytes: typeof rsaPrivateKeyBytes; normalizeTextDigestResult: typeof normalizeTextDigestResult };
+export default provider;
+
+export declare function rsaPrivateKeyBytes(components: Readonly<Record<string, unknown>>): Promise<Uint8Array>;