@adcp/sdk 16.0.0-beta.2 → 16.0.0-beta.3

package/dist/lib/signing/crypto.js

@@ -19,7 +19,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var crypto_exports = {};
 __export(crypto_exports, {
   jwkToPublicKey: () => jwkToPublicKey,
-  verifySignature: () => verifySignature
+  signWithPrivateJwk: () => signWithPrivateJwk,
+  signWithPrivateJwkAsync: () => signWithPrivateJwkAsync,
+  verifySignature: () => verifySignature,
+  verifySignatureAsync: () => verifySignatureAsync
 });
 module.exports = __toCommonJS(crypto_exports);
 var import_crypto = require("crypto");
@@ -45,7 +48,16 @@ function verifySignature(alg, publicKey, data, signature) {
       return (0, import_crypto.verify)(null, data, publicKey, signature);
     }
     if (alg === "ecdsa-p256-sha256") {
-      return (0, import_crypto.verify)("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      try {
+        return (0, import_crypto.verify)("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      } catch {
+        return (0, import_crypto.verify)(
+          "sha256",
+          data,
+          { key: publicKey.export({ format: "jwk" }), format: "jwk", dsaEncoding: "ieee-p1363" },
+          signature
+        );
+      }
     }
     if (alg === "rsa-pss-sha512") {
       return (0, import_crypto.verify)(
@@ -60,8 +72,68 @@ function verifySignature(alg, publicKey, data, signature) {
     return false;
   }
 }
+function subtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  return subtle && typeof subtle.importKey === "function" ? subtle : void 0;
+}
+const P256 = { name: "ECDSA", namedCurve: "P-256" };
+const P256_SHA256 = { name: "ECDSA", hash: "SHA-256" };
+function publicP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y };
+}
+function privateP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y, d: jwk.d };
+}
+async function verifySignatureAsync(alg, publicKey, data, signature) {
+  const subtle = subtleCrypto();
+  const keyObject = () => isKeyObject(publicKey) ? publicKey : jwkToPublicKey(publicKey);
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return verifySignature(alg, keyObject(), data, signature);
+  try {
+    const jwk = isKeyObject(publicKey) ? publicKey.export({ format: "jwk" }) : publicKey;
+    const key = await importP256VerifyKey(subtle, jwk);
+    return await subtle.verify(P256_SHA256, key, toArrayBuffer(signature), toArrayBuffer(data));
+  } catch {
+    return false;
+  }
+}
+function isKeyObject(value) {
+  return typeof value?.export === "function" && "asymmetricKeyType" in value;
+}
+const p256VerifyKeys = /* @__PURE__ */ new Map();
+function importP256VerifyKey(subtle, jwk) {
+  if (jwk.kty !== "EC" || jwk.crv !== "P-256" || typeof jwk.x !== "string" || typeof jwk.y !== "string")
+    return Promise.reject(new TypeError("Not a P-256 public key"));
+  const cacheKey = `${jwk.x}.${jwk.y}`;
+  let key = p256VerifyKeys.get(cacheKey);
+  if (!key) {
+    key = subtle.importKey("jwk", publicP256Jwk(jwk), P256, false, ["verify"]);
+    key.catch(() => p256VerifyKeys.delete(cacheKey));
+    if (p256VerifyKeys.size >= 256) p256VerifyKeys.delete(p256VerifyKeys.keys().next().value);
+    p256VerifyKeys.set(cacheKey, key);
+  }
+  return key;
+}
+function signWithPrivateJwk(alg, privateJwk, data) {
+  if (alg === "ed25519")
+    return new Uint8Array((0, import_crypto.sign)(null, data, (0, import_crypto.createPrivateKey)({ key: privateJwk, format: "jwk" })));
+  if (alg === "ecdsa-p256-sha256")
+    return new Uint8Array((0, import_crypto.sign)("sha256", data, { key: privateJwk, format: "jwk", dsaEncoding: "ieee-p1363" }));
+  throw new TypeError(`Unsupported signing algorithm: ${alg}`);
+}
+async function signWithPrivateJwkAsync(alg, privateJwk, data) {
+  const subtle = subtleCrypto();
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return signWithPrivateJwk(alg, privateJwk, data);
+  const key = await subtle.importKey("jwk", privateP256Jwk(privateJwk), P256, false, ["sign"]);
+  return new Uint8Array(await subtle.sign(P256_SHA256, key, toArrayBuffer(data)));
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   jwkToPublicKey,
-  verifySignature
+  signWithPrivateJwk,
+  signWithPrivateJwkAsync,
+  verifySignature,
+  verifySignatureAsync
 });

package/dist/lib/signing/crypto.mjs

@@ -1,4 +1,10 @@
-import { constants, createPublicKey, verify as nodeVerify } from "crypto";
+import {
+  constants,
+  createPrivateKey,
+  createPublicKey,
+  sign as nodeSign,
+  verify as nodeVerify
+} from "crypto";
 import { RequestSignatureError } from "./errors.mjs";
 function jwkToPublicKey(jwk) {
   const publicJwk = { ...jwk };
@@ -21,7 +27,16 @@ function verifySignature(alg, publicKey, data, signature) {
       return nodeVerify(null, data, publicKey, signature);
     }
     if (alg === "ecdsa-p256-sha256") {
-      return nodeVerify("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      try {
+        return nodeVerify("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      } catch {
+        return nodeVerify(
+          "sha256",
+          data,
+          { key: publicKey.export({ format: "jwk" }), format: "jwk", dsaEncoding: "ieee-p1363" },
+          signature
+        );
+      }
     }
     if (alg === "rsa-pss-sha512") {
       return nodeVerify(
@@ -36,7 +51,67 @@ function verifySignature(alg, publicKey, data, signature) {
     return false;
   }
 }
+function subtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  return subtle && typeof subtle.importKey === "function" ? subtle : void 0;
+}
+const P256 = { name: "ECDSA", namedCurve: "P-256" };
+const P256_SHA256 = { name: "ECDSA", hash: "SHA-256" };
+function publicP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y };
+}
+function privateP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y, d: jwk.d };
+}
+async function verifySignatureAsync(alg, publicKey, data, signature) {
+  const subtle = subtleCrypto();
+  const keyObject = () => isKeyObject(publicKey) ? publicKey : jwkToPublicKey(publicKey);
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return verifySignature(alg, keyObject(), data, signature);
+  try {
+    const jwk = isKeyObject(publicKey) ? publicKey.export({ format: "jwk" }) : publicKey;
+    const key = await importP256VerifyKey(subtle, jwk);
+    return await subtle.verify(P256_SHA256, key, toArrayBuffer(signature), toArrayBuffer(data));
+  } catch {
+    return false;
+  }
+}
+function isKeyObject(value) {
+  return typeof value?.export === "function" && "asymmetricKeyType" in value;
+}
+const p256VerifyKeys = /* @__PURE__ */ new Map();
+function importP256VerifyKey(subtle, jwk) {
+  if (jwk.kty !== "EC" || jwk.crv !== "P-256" || typeof jwk.x !== "string" || typeof jwk.y !== "string")
+    return Promise.reject(new TypeError("Not a P-256 public key"));
+  const cacheKey = `${jwk.x}.${jwk.y}`;
+  let key = p256VerifyKeys.get(cacheKey);
+  if (!key) {
+    key = subtle.importKey("jwk", publicP256Jwk(jwk), P256, false, ["verify"]);
+    key.catch(() => p256VerifyKeys.delete(cacheKey));
+    if (p256VerifyKeys.size >= 256) p256VerifyKeys.delete(p256VerifyKeys.keys().next().value);
+    p256VerifyKeys.set(cacheKey, key);
+  }
+  return key;
+}
+function signWithPrivateJwk(alg, privateJwk, data) {
+  if (alg === "ed25519")
+    return new Uint8Array(nodeSign(null, data, createPrivateKey({ key: privateJwk, format: "jwk" })));
+  if (alg === "ecdsa-p256-sha256")
+    return new Uint8Array(nodeSign("sha256", data, { key: privateJwk, format: "jwk", dsaEncoding: "ieee-p1363" }));
+  throw new TypeError(`Unsupported signing algorithm: ${alg}`);
+}
+async function signWithPrivateJwkAsync(alg, privateJwk, data) {
+  const subtle = subtleCrypto();
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return signWithPrivateJwk(alg, privateJwk, data);
+  const key = await subtle.importKey("jwk", privateP256Jwk(privateJwk), P256, false, ["sign"]);
+  return new Uint8Array(await subtle.sign(P256_SHA256, key, toArrayBuffer(data)));
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
 export {
   jwkToPublicKey,
-  verifySignature
+  signWithPrivateJwk,
+  signWithPrivateJwkAsync,
+  verifySignature,
+  verifySignatureAsync
 };

package/dist/lib/signing/server.d.mts

@@ -12,7 +12,7 @@ export type { SsrfDnsLookup } from '../net/index.mjs';
 export { buildResponseSignatureBase, buildSignatureBase, canonicalAuthority, canonicalMethod, canonicalTargetUri, formatSignatureParams, getHeaderValue, type RequestLike, type RequestCanonicalizationProfile, type ResponseLike, type SignatureParams, } from './canonicalize.mjs';
 export { computeContentDigest, contentDigestMatches, parseContentDigest } from './content-digest.mjs';
 export { requestContextFromExpress, requestContextFromFetch, requestContextFromLambda, type ExpressRequestLike, type FetchRequestLike, type LambdaRequestEvent, type RequestContextFromExpressOptions, type RequestContextFromLambdaOptions, } from './request-context.mjs';
-export { jwkToPublicKey, verifySignature } from './crypto.mjs';
+export { jwkToPublicKey, verifySignature, verifySignatureAsync } from './crypto.mjs';
 export { RequestSignatureError, RequestSigningErrorCodeMetadata, type RequestSignatureErrorCode, ResponseSignatureError, type ResponseSignatureErrorCode, WebhookSignatureError, type WebhookSignatureErrorCode, } from './errors.mjs';
 export { StaticJwksResolver, type JwksResolution, type JwksResolver } from './jwks.mjs';
 export { HttpsJwksResolver, type HttpsJwksResolverOptions } from './jwks-https.mjs';

package/dist/lib/signing/server.d.ts

@@ -12,7 +12,7 @@ export type { SsrfDnsLookup } from '../net';
 export { buildResponseSignatureBase, buildSignatureBase, canonicalAuthority, canonicalMethod, canonicalTargetUri, formatSignatureParams, getHeaderValue, type RequestLike, type RequestCanonicalizationProfile, type ResponseLike, type SignatureParams, } from './canonicalize';
 export { computeContentDigest, contentDigestMatches, parseContentDigest } from './content-digest';
 export { requestContextFromExpress, requestContextFromFetch, requestContextFromLambda, type ExpressRequestLike, type FetchRequestLike, type LambdaRequestEvent, type RequestContextFromExpressOptions, type RequestContextFromLambdaOptions, } from './request-context';
-export { jwkToPublicKey, verifySignature } from './crypto';
+export { jwkToPublicKey, verifySignature, verifySignatureAsync } from './crypto';
 export { RequestSignatureError, RequestSigningErrorCodeMetadata, type RequestSignatureErrorCode, ResponseSignatureError, type ResponseSignatureErrorCode, WebhookSignatureError, type WebhookSignatureErrorCode, } from './errors';
 export { StaticJwksResolver, type JwksResolution, type JwksResolver } from './jwks';
 export { HttpsJwksResolver, type HttpsJwksResolverOptions } from './jwks-https';

package/dist/lib/signing/server.js

@@ -83,6 +83,7 @@ __export(server_exports, {
   sweepExpiredReplays: () => import_postgres_replay_store.sweepExpiredReplays,
   verifyRequestSignature: () => import_verifier.verifyRequestSignature,
   verifySignature: () => import_crypto.verifySignature,
+  verifySignatureAsync: () => import_crypto.verifySignatureAsync,
   verifyWebhookSignature: () => import_webhook_verifier.verifyWebhookSignature
 });
 module.exports = __toCommonJS(server_exports);
@@ -175,5 +176,6 @@ var import_agent_resolver = require('./agent-resolver/index.js');
   sweepExpiredReplays,
   verifyRequestSignature,
   verifySignature,
+  verifySignatureAsync,
   verifyWebhookSignature
 });

package/dist/lib/signing/server.mjs

@@ -13,7 +13,7 @@ import {
   requestContextFromFetch,
   requestContextFromLambda
 } from "./request-context.mjs";
-import { jwkToPublicKey, verifySignature } from "./crypto.mjs";
+import { jwkToPublicKey, verifySignature, verifySignatureAsync } from "./crypto.mjs";
 import {
   RequestSignatureError,
   RequestSigningErrorCodeMetadata,
@@ -150,5 +150,6 @@ export {
   sweepExpiredReplays,
   verifyRequestSignature,
   verifySignature,
+  verifySignatureAsync,
   verifyWebhookSignature
 };

package/dist/lib/signing/signer.js

@@ -32,6 +32,7 @@ __export(signer_exports, {
 });
 module.exports = __toCommonJS(signer_exports);
 var import_crypto = require("crypto");
+var import_crypto2 = require('./crypto.js');
 var import_canonicalize = require('./canonicalize.js');
 var import_content_digest = require('./content-digest.js');
 var import_errors = require('./errors.js');
@@ -203,14 +204,7 @@ function signResponse(response, key, options = {}) {
   return finalizeResponseSignature(prepared, signature);
 }
 function produceSignature(key, data) {
-  const privateKey = (0, import_crypto.createPrivateKey)({
-    key: key.privateKey,
-    format: "jwk"
-  });
-  if (key.alg === "ed25519") {
-    return new Uint8Array((0, import_crypto.sign)(null, data, privateKey));
-  }
-  return new Uint8Array((0, import_crypto.sign)("sha256", data, { key: privateKey, dsaEncoding: "ieee-p1363" }));
+  return (0, import_crypto2.signWithPrivateJwk)(key.alg, key.privateKey, data);
 }
 function flattenHeaders(headers) {
   const out = {};

package/dist/lib/signing/signer.mjs

@@ -1,4 +1,5 @@
-import { createPrivateKey, randomBytes, sign as nodeSign } from "crypto";
+import { randomBytes } from "crypto";
+import { signWithPrivateJwk } from "./crypto.mjs";
 import {
   buildResponseSignatureBase,
   buildSignatureBase,
@@ -180,14 +181,7 @@ function signResponse(response, key, options = {}) {
   return finalizeResponseSignature(prepared, signature);
 }
 function produceSignature(key, data) {
-  const privateKey = createPrivateKey({
-    key: key.privateKey,
-    format: "jwk"
-  });
-  if (key.alg === "ed25519") {
-    return new Uint8Array(nodeSign(null, data, privateKey));
-  }
-  return new Uint8Array(nodeSign("sha256", data, { key: privateKey, dsaEncoding: "ieee-p1363" }));
+  return signWithPrivateJwk(key.alg, key.privateKey, data);
 }
 function flattenHeaders(headers) {
   const out = {};

package/dist/lib/signing/testing.js

@@ -35,6 +35,7 @@ __export(testing_exports, {
 });
 module.exports = __toCommonJS(testing_exports);
 var import_node_crypto = require("node:crypto");
+var import_crypto = require('./crypto.js');
 var import_jwks_helpers = require('./jwks-helpers.js');
 const ALLOW_IN_MEMORY_SIGNER_ENV = "ADCP_ALLOW_IN_MEMORY_SIGNER";
 class InMemorySigningProvider {
@@ -61,12 +62,7 @@ class InMemorySigningProvider {
     this.fingerprint = (0, import_node_crypto.createHash)("sha256").update(options.keyid).update("\0").update(options.privateKey.d).digest("hex").slice(0, 16);
   }
   async sign(payload) {
-    const privateKey = (0, import_node_crypto.createPrivateKey)({ key: this.privateKey, format: "jwk" });
-    const data = Buffer.from(payload);
-    if (this.algorithm === "ed25519") {
-      return new Uint8Array((0, import_node_crypto.sign)(null, data, privateKey));
-    }
-    return new Uint8Array((0, import_node_crypto.sign)("sha256", data, { key: privateKey, dsaEncoding: "ieee-p1363" }));
+    return (0, import_crypto.signWithPrivateJwkAsync)(this.algorithm, this.privateKey, payload);
   }
 }
 function signerKeyToProvider(key) {

package/dist/lib/signing/testing.mjs

@@ -1,4 +1,5 @@
-import { createHash, createPrivateKey, randomUUID, sign as nodeSign } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { signWithPrivateJwkAsync } from "./crypto.mjs";
 import { assertAdcpUse } from "./jwks-helpers.mjs";
 const ALLOW_IN_MEMORY_SIGNER_ENV = "ADCP_ALLOW_IN_MEMORY_SIGNER";
 class InMemorySigningProvider {
@@ -25,12 +26,7 @@ class InMemorySigningProvider {
     this.fingerprint = createHash("sha256").update(options.keyid).update("\0").update(options.privateKey.d).digest("hex").slice(0, 16);
   }
   async sign(payload) {
-    const privateKey = createPrivateKey({ key: this.privateKey, format: "jwk" });
-    const data = Buffer.from(payload);
-    if (this.algorithm === "ed25519") {
-      return new Uint8Array(nodeSign(null, data, privateKey));
-    }
-    return new Uint8Array(nodeSign("sha256", data, { key: privateKey, dsaEncoding: "ieee-p1363" }));
+    return signWithPrivateJwkAsync(this.algorithm, this.privateKey, payload);
   }
 }
 function signerKeyToProvider(key) {

package/dist/lib/signing/verifier.js

@@ -191,8 +191,8 @@ async function verifyRequestSignature(request, options) {
     parsedInput.signatureParamsValue,
     canonicalizationProfile
   );
-  const publicKey = (0, import_crypto.jwkToPublicKey)(jwk);
-  const valid = (0, import_crypto.verifySignature)(parsedInput.params.alg, publicKey, Buffer.from(base, "utf8"), parsedSig.bytes);
+  (0, import_crypto.jwkToPublicKey)(jwk);
+  const valid = await (0, import_crypto.verifySignatureAsync)(parsedInput.params.alg, jwk, Buffer.from(base, "utf8"), parsedSig.bytes);
   if (!valid) {
     throw new import_errors.RequestSignatureError(
       "request_signature_invalid",

package/dist/lib/signing/verifier.mjs

@@ -16,7 +16,7 @@ import { RequestSignatureError } from "./errors.mjs";
 import { AgentResolverError } from "./agent-resolver/errors.mjs";
 import { parseStrictJson, StrictJsonError } from "./agent-resolver/strict-json.mjs";
 import { parseSignature, parseSignatureInput } from "./parser.mjs";
-import { jwkToPublicKey, verifySignature } from "./crypto.mjs";
+import { jwkToPublicKey, verifySignatureAsync } from "./crypto.mjs";
 import { isUnresolvableOperation } from "./operation-resolution.mjs";
 import { containsWebhookAuthentication, WEBHOOK_AUTH_TRAVERSAL_DEPTH } from "./webhook-auth-detection.mjs";
 import {
@@ -180,8 +180,8 @@ async function verifyRequestSignature(request, options) {
     parsedInput.signatureParamsValue,
     canonicalizationProfile
   );
-  const publicKey = jwkToPublicKey(jwk);
-  const valid = verifySignature(parsedInput.params.alg, publicKey, Buffer.from(base, "utf8"), parsedSig.bytes);
+  jwkToPublicKey(jwk);
+  const valid = await verifySignatureAsync(parsedInput.params.alg, jwk, Buffer.from(base, "utf8"), parsedSig.bytes);
   if (!valid) {
     throw new RequestSignatureError(
       "request_signature_invalid",

package/dist/lib/signing/web-bot-auth.js

@@ -237,17 +237,29 @@ function assertDigest(headers, body) {
   if (!digest || !(0, import_content_digest.contentDigestUsesEncoding)(digest, "rfc8941-base64") || !(0, import_content_digest.contentDigestMatches)(digest, body))
     denied("content_digest");
 }
-function verifyBytes(input, request, jwk, response) {
+function signatureBytes(input, request, jwk, response) {
   const alg = algorithm(jwk);
   if (input.params.alg !== void 0 && input.params.alg !== alg) denied("algorithm");
   const signature = (0, import_canonicalize2.getHeaderValue)(response?.headers ?? request.headers, "signature");
   if (signature === void 0 || signature === "") denied("headers_missing");
-  let bytes;
   try {
-    bytes = (0, import_parser.parseSignature)(signature ?? "", input.label, "rfc8941-base64").bytes;
+    return { alg, bytes: (0, import_parser.parseSignature)(signature ?? "", input.label, "rfc8941-base64").bytes };
   } catch {
     return bad("signature");
   }
+}
+async function verifyBytesAsync(input, request, jwk) {
+  const { alg, bytes } = signatureBytes(input, request, jwk);
+  let valid = false;
+  try {
+    valid = await (0, import_crypto2.verifySignatureAsync)(alg, jwk, Buffer.from(buildWebBotAuthSignatureBase(input, request)), bytes);
+  } catch (error) {
+    if (error instanceof WebBotAuthError) throw error;
+  }
+  if (!valid) denied("signature_invalid");
+}
+function verifyBytes(input, request, jwk, response) {
+  const { alg, bytes } = signatureBytes(input, request, jwk, response);
   let valid = false;
   try {
     valid = (0, import_crypto2.verifySignature)(
@@ -419,7 +431,7 @@ async function verifyWebBotAuth(request, options) {
         denied("directory_key");
       const key = checkedDirectory.keys.find((key2) => key2.kid === keyid);
       if (!key || jwkThumbprint(key) !== keyid) denied("key");
-      verifyBytes(input, request, key);
+      await verifyBytesAsync(input, request, key);
       if (options.isRevoked) await legacyRevocationCheck(options, origin, keyid);
       const nonceTuple = JSON.stringify([origin, nonce]);
       if (nonces.has(nonceTuple)) throw new WebBotAuthError(options.replayStatus ?? 429, "nonce_replayed");
@@ -665,14 +677,15 @@ async function signBase(base, key) {
       throw new TypeError("Web Bot Auth provider identity does not match its public key");
     return key.provider.sign(Buffer.from(base));
   }
-  const privateKey = (0, import_crypto.createPrivateKey)({ key: jwk, format: "jwk" });
-  if (alg === "rsa-pss-sha512")
+  if (alg === "rsa-pss-sha512") {
+    const privateKey = (0, import_crypto.createPrivateKey)({ key: jwk, format: "jwk" });
     return (0, import_crypto.sign)("sha512", Buffer.from(base), {
       key: privateKey,
       padding: import_crypto.constants.RSA_PKCS1_PSS_PADDING,
       saltLength: 64
     });
-  return alg === "ed25519" ? (0, import_crypto.sign)(null, Buffer.from(base), privateKey) : (0, import_crypto.sign)("sha256", Buffer.from(base), { key: privateKey, dsaEncoding: "ieee-p1363" });
+  }
+  return (0, import_crypto2.signWithPrivateJwkAsync)(alg, jwk, Buffer.from(base));
 }
 async function signWebBotAuth(request, key, options) {
   const origin = (0, import_canonicalize.canonicalAgentOrigin)(options.origin);

package/dist/lib/signing/web-bot-auth.mjs

@@ -14,7 +14,7 @@ import { canonicalAgentUrl } from "./agent-resolver/select-agent.mjs";
 import { parseStrictJson } from "./agent-resolver/strict-json.mjs";
 import { getHeaderValue } from "./canonicalize.mjs";
 import { computeContentDigest, contentDigestMatches, contentDigestUsesEncoding } from "./content-digest.mjs";
-import { jwkToPublicKey, verifySignature } from "./crypto.mjs";
+import { jwkToPublicKey, signWithPrivateJwkAsync, verifySignature, verifySignatureAsync } from "./crypto.mjs";
 import {
   parseSignature,
   parseSignatureInput,
@@ -197,17 +197,29 @@ function assertDigest(headers, body) {
   if (!digest || !contentDigestUsesEncoding(digest, "rfc8941-base64") || !contentDigestMatches(digest, body))
     denied("content_digest");
 }
-function verifyBytes(input, request, jwk, response) {
+function signatureBytes(input, request, jwk, response) {
   const alg = algorithm(jwk);
   if (input.params.alg !== void 0 && input.params.alg !== alg) denied("algorithm");
   const signature = getHeaderValue(response?.headers ?? request.headers, "signature");
   if (signature === void 0 || signature === "") denied("headers_missing");
-  let bytes;
   try {
-    bytes = parseSignature(signature ?? "", input.label, "rfc8941-base64").bytes;
+    return { alg, bytes: parseSignature(signature ?? "", input.label, "rfc8941-base64").bytes };
   } catch {
     return bad("signature");
   }
+}
+async function verifyBytesAsync(input, request, jwk) {
+  const { alg, bytes } = signatureBytes(input, request, jwk);
+  let valid = false;
+  try {
+    valid = await verifySignatureAsync(alg, jwk, Buffer.from(buildWebBotAuthSignatureBase(input, request)), bytes);
+  } catch (error) {
+    if (error instanceof WebBotAuthError) throw error;
+  }
+  if (!valid) denied("signature_invalid");
+}
+function verifyBytes(input, request, jwk, response) {
+  const { alg, bytes } = signatureBytes(input, request, jwk, response);
   let valid = false;
   try {
     valid = verifySignature(
@@ -379,7 +391,7 @@ async function verifyWebBotAuth(request, options) {
         denied("directory_key");
       const key = checkedDirectory.keys.find((key2) => key2.kid === keyid);
       if (!key || jwkThumbprint(key) !== keyid) denied("key");
-      verifyBytes(input, request, key);
+      await verifyBytesAsync(input, request, key);
       if (options.isRevoked) await legacyRevocationCheck(options, origin, keyid);
       const nonceTuple = JSON.stringify([origin, nonce]);
       if (nonces.has(nonceTuple)) throw new WebBotAuthError(options.replayStatus ?? 429, "nonce_replayed");
@@ -625,14 +637,15 @@ async function signBase(base, key) {
       throw new TypeError("Web Bot Auth provider identity does not match its public key");
     return key.provider.sign(Buffer.from(base));
   }
-  const privateKey = createPrivateKey({ key: jwk, format: "jwk" });
-  if (alg === "rsa-pss-sha512")
+  if (alg === "rsa-pss-sha512") {
+    const privateKey = createPrivateKey({ key: jwk, format: "jwk" });
     return nodeSign("sha512", Buffer.from(base), {
       key: privateKey,
       padding: cryptoConstants.RSA_PKCS1_PSS_PADDING,
       saltLength: 64
     });
-  return alg === "ed25519" ? nodeSign(null, Buffer.from(base), privateKey) : nodeSign("sha256", Buffer.from(base), { key: privateKey, dsaEncoding: "ieee-p1363" });
+  }
+  return signWithPrivateJwkAsync(alg, jwk, Buffer.from(base));
 }
 async function signWebBotAuth(request, key, options) {
   const origin = canonicalAgentOrigin(options.origin);

package/dist/lib/signing/webhook-verifier.js

@@ -172,8 +172,8 @@ async function verifyWebhookSignature(request, options) {
     parsedInput.signatureParamsValue,
     "3.2"
   );
-  const publicKey = (0, import_crypto.jwkToPublicKey)(jwk);
-  const valid = (0, import_crypto.verifySignature)(parsedInput.params.alg, publicKey, Buffer.from(base, "utf8"), parsedSig.bytes);
+  (0, import_crypto.jwkToPublicKey)(jwk);
+  const valid = await (0, import_crypto.verifySignatureAsync)(parsedInput.params.alg, jwk, Buffer.from(base, "utf8"), parsedSig.bytes);
   if (!valid) {
     throw new import_errors.WebhookSignatureError(
       "webhook_signature_invalid",

package/dist/lib/signing/webhook-verifier.mjs

@@ -4,7 +4,7 @@ import { RequestSignatureError, WebhookSignatureError } from "./errors.mjs";
 import { AgentResolverError } from "./agent-resolver/errors.mjs";
 import { BrandJsonResolverError } from "./brand-jwks.mjs";
 import { parseSignature, parseSignatureInput } from "./parser.mjs";
-import { jwkToPublicKey, verifySignature } from "./crypto.mjs";
+import { jwkToPublicKey, verifySignatureAsync } from "./crypto.mjs";
 import { assertPublisherPins } from "./publisher-pins.mjs";
 import { InMemoryReplayStore } from "./replay.mjs";
 import { InMemoryRevocationStore } from "./revocation.mjs";
@@ -145,8 +145,8 @@ async function verifyWebhookSignature(request, options) {
     parsedInput.signatureParamsValue,
     "3.2"
   );
-  const publicKey = jwkToPublicKey(jwk);
-  const valid = verifySignature(parsedInput.params.alg, publicKey, Buffer.from(base, "utf8"), parsedSig.bytes);
+  jwkToPublicKey(jwk);
+  const valid = await verifySignatureAsync(parsedInput.params.alg, jwk, Buffer.from(base, "utf8"), parsedSig.bytes);
   if (!valid) {
     throw new WebhookSignatureError(
       "webhook_signature_invalid",

package/dist/lib/substitution/compile.js

@@ -22,6 +22,7 @@ __export(compile_exports, {
 });
 module.exports = __toCommonJS(compile_exports);
 var import_enums = require('../types/enums.generated.js');
+var import_consent_macros = require('./consent-macros.js');
 const BUILT_IN_SOURCE_SYNTAXES = /* @__PURE__ */ new Set([
   "adcp",
   "double_brace",
@@ -61,7 +62,7 @@ function universalMacroName(token) {
 }
 function isUniversalMacro(token) {
   const name = universalMacroName(token);
-  return name !== null && UNIVERSAL_MACRO_NAMES.has(name);
+  return name !== null && (UNIVERSAL_MACRO_NAMES.has(name) || (0, import_consent_macros.isConsentMacro)(token));
 }
 function syntaxForExactToken(token, builtIns, customSyntaxes) {
   for (const syntax of customSyntaxes) {

package/dist/lib/substitution/compile.mjs

@@ -1,4 +1,5 @@
 import { UniversalMacroValues } from "../types/enums.generated.mjs";
+import { isConsentMacro } from "./consent-macros.mjs";
 const BUILT_IN_SOURCE_SYNTAXES = /* @__PURE__ */ new Set([
   "adcp",
   "double_brace",
@@ -38,7 +39,7 @@ function universalMacroName(token) {
 }
 function isUniversalMacro(token) {
   const name = universalMacroName(token);
-  return name !== null && UNIVERSAL_MACRO_NAMES.has(name);
+  return name !== null && (UNIVERSAL_MACRO_NAMES.has(name) || isConsentMacro(token));
 }
 function syntaxForExactToken(token, builtIns, customSyntaxes) {
   for (const syntax of customSyntaxes) {

package/dist/lib/substitution/consent-macros.d.mts

@@ -0,0 +1,4 @@
+/** The complete token retains the receiving vendor's positive decimal GVL ID. */
+export declare function isVendorScopedConsentMacro(token: string): boolean;
+/** Recognize privacy signals for helper compilation and consent diagnostics. */
+export declare function isConsentMacro(token: string): boolean;

package/dist/lib/substitution/consent-macros.d.ts

@@ -0,0 +1,4 @@
+/** The complete token retains the receiving vendor's positive decimal GVL ID. */
+export declare function isVendorScopedConsentMacro(token: string): boolean;
+/** Recognize privacy signals for helper compilation and consent diagnostics. */
+export declare function isConsentMacro(token: string): boolean;

package/dist/lib/substitution/consent-macros.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var consent_macros_exports = {};
+__export(consent_macros_exports, {
+  isConsentMacro: () => isConsentMacro,
+  isVendorScopedConsentMacro: () => isVendorScopedConsentMacro
+});
+module.exports = __toCommonJS(consent_macros_exports);
+const VENDOR_SCOPED_CONSENT_MACRO = /^\{GDPR_CONSENT_[1-9][0-9]*\}$/;
+const CONSENT_MACROS = /* @__PURE__ */ new Set([
+  "{GDPR}",
+  "{GDPR_CONSENT}",
+  "{ADDTL_CONSENT}",
+  "{US_PRIVACY}",
+  "{GPP_STRING}",
+  "{GPP_SID}",
+  "{LIMIT_AD_TRACKING}"
+]);
+function isVendorScopedConsentMacro(token) {
+  return VENDOR_SCOPED_CONSENT_MACRO.test(token);
+}
+function isConsentMacro(token) {
+  return CONSENT_MACROS.has(token) || isVendorScopedConsentMacro(token);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isConsentMacro,
+  isVendorScopedConsentMacro
+});