wao 0.41.3 → 0.41.5

package/hbsig/dist/cjs/parser.js

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeSigInput = decodeSigInput;
+exports.extractPubKey = extractPubKey;
+exports.extractPublicKeyFromMessage = extractPublicKeyFromMessage;
+var _base64url = _interopRequireDefault(require("base64url"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Decode signature-input header to extract all components
+ * Handles format: signature-name=(components);params
+ *
+ * @param {string} signatureInput - The signature-input header value
+ * @param {string} [signatureName] - Optional specific signature name to decode
+ * @returns {Object} Decoded signature input with components and parameters
+ */
+function decodeSigInput(signatureInput) {
+  var signatureName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (!signatureInput) {
+    return null;
+  }
+  try {
+    // If signature name is provided, extract just that section
+    var inputToDecode = signatureInput;
+    if (signatureName) {
+      // Find the section for this specific signature
+      var startIndex = signatureInput.indexOf(signatureName);
+      if (startIndex === -1) {
+        return null;
+      }
+
+      // Extract from signature name to the next signature (if any) or end
+      var nextSigMatch = signatureInput.substring(startIndex + signatureName.length).match(/,\s*[a-zA-Z0-9_-]+=/);
+      var endIndex = nextSigMatch ? startIndex + signatureName.length + nextSigMatch.index : signatureInput.length;
+      inputToDecode = signatureInput.substring(startIndex, endIndex).trim();
+    }
+
+    // Parse each signature entry
+    var signatures = {};
+
+    // Split by signature entries (handle multiple signatures)
+    var entries = inputToDecode.split(/,(?=\s*[a-zA-Z0-9_-]+=)/);
+    var _iterator = _createForOfIteratorHelper(entries),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        var trimmedEntry = entry.trim();
+
+        // Match signature-name=(components);params format
+        var match = trimmedEntry.match(/^([a-zA-Z0-9_-]+)=\(([^)]*)\)(.*)$/);
+        if (!match) {
+          continue;
+        }
+        var sigName = match[1];
+        var componentsStr = match[2];
+        var paramsStr = match[3];
+
+        // Parse components (space-separated, may be quoted)
+        var components = [];
+        var componentRegex = /"[^"]+"|[^\s]+/g;
+        var componentMatch = void 0;
+        while ((componentMatch = componentRegex.exec(componentsStr)) !== null) {
+          components.push(componentMatch[0].replace(/"/g, ""));
+        }
+
+        // Parse parameters (semicolon-separated key="value" pairs)
+        var params = {};
+        if (paramsStr) {
+          var paramPairs = paramsStr.split(";").filter(function (p) {
+            return p.trim();
+          });
+          var _iterator2 = _createForOfIteratorHelper(paramPairs),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var pair = _step2.value;
+              var _pair$split = pair.split("="),
+                _pair$split2 = _toArray(_pair$split),
+                key = _pair$split2[0],
+                valueParts = _pair$split2.slice(1);
+              if (key && valueParts.length > 0) {
+                var value = valueParts.join("=").replace(/^"|"$/g, "");
+                params[key.trim()] = value;
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+        signatures[sigName] = {
+          components: components,
+          params: params,
+          raw: trimmedEntry
+        };
+      }
+
+      // If specific signature was requested, return just that one
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    if (signatureName && signatures[signatureName]) {
+      return signatures[signatureName];
+    }
+
+    // Return all signatures or the first one if no specific name was given
+    return signatureName ? null : signatures;
+  } catch (error) {
+    console.error("Error decoding signature-input:", error);
+    return null;
+  }
+}
+
+/**
+ * Extract signature name from headers
+ * @param {Object} headers - Request headers
+ * @returns {string|null} Signature name or null
+ */
+function extractSignatureName(headers) {
+  var signatureHeader = headers["signature"] || headers["Signature"];
+  if (!signatureHeader) return null;
+
+  // Extract signature name (e.g., "http-sig-xxxxxxxx")
+  // Handle both "name:" and "name=" formats
+  var match = signatureHeader.match(/^([^:=]+)[:=]/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Extract public key from signature-input header
+ * @param {Object} headers - Request headers
+ * @param {string} [signatureName] - Optional signature name to look for
+ * @returns {Buffer|null} Public key buffer or null
+ */
+function extractPubKey(headers, signatureName) {
+  var signatureInput = headers["signature-input"] || headers["Signature-Input"];
+  if (!signatureInput) return null;
+
+  // Use the decoder to properly parse the signature-input
+  var decoded = decodeSigInput(signatureInput, signatureName);
+  if (!decoded) return null;
+
+  // If we decoded a specific signature, use its keyid
+  // When no specific signatureName, prefer RSA signature over HMAC
+  // (HMAC keyid is "constant:ao" which is not a real public key)
+  var keyid = null;
+  if (signatureName && decoded.params) {
+    keyid = decoded.params.keyid;
+  } else {
+    var _rsaEntry$params, _entries$;
+    var entries = Object.values(decoded);
+    var rsaEntry = entries.find(function (e) {
+      var _e$params;
+      return (_e$params = e.params) === null || _e$params === void 0 || (_e$params = _e$params.alg) === null || _e$params === void 0 ? void 0 : _e$params.startsWith("rsa-");
+    });
+    keyid = (rsaEntry === null || rsaEntry === void 0 || (_rsaEntry$params = rsaEntry.params) === null || _rsaEntry$params === void 0 ? void 0 : _rsaEntry$params.keyid) || ((_entries$ = entries[0]) === null || _entries$ === void 0 || (_entries$ = _entries$.params) === null || _entries$ === void 0 ? void 0 : _entries$.keyid);
+  }
+  if (!keyid) return null;
+  try {
+    // Strip scheme prefix if present (e.g., "publickey:base64data" -> "base64data")
+    var keyidToDecode = keyid;
+    if (keyid.includes(":")) {
+      var colonIndex = keyid.indexOf(":");
+      keyidToDecode = keyid.substring(colonIndex + 1);
+    }
+    // Handle both base64url and standard base64 encoding
+    // Standard base64 uses +/ while base64url uses -_
+    if (keyidToDecode.includes("+") || keyidToDecode.includes("/")) {
+      // Standard base64 - convert to buffer directly
+      return Buffer.from(keyidToDecode, "base64");
+    }
+    return _base64url["default"].toBuffer(keyidToDecode);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Extract public key from a signed message
+ * This is a convenience wrapper that extracts the signature name first
+ *
+ * @param {Object} signedMessage - The signed message with headers
+ * @returns {Buffer|null} The public key buffer or null
+ */
+function extractPublicKeyFromMessage(signedMessage) {
+  var signatureName = extractSignatureName(signedMessage.headers);
+  return extractPubKey(signedMessage.headers, signatureName);
+}