hbsig 0.1.3 → 0.1.5

package/cjs/httpsig.js

@@ -5,10 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.httpsig_from = httpsig_from;
 exports.httpsig_to = httpsig_to;
+exports.structured_from = structured_from;
+exports.structured_to = structured_to;
 var _crypto = _interopRequireDefault(require("crypto"));
 var _flat = require("./flat.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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); }
@@ -342,7 +343,22 @@ function encodeBodyPart(partName, bodyPart, inlineKey) {
   return "";
 }
 
-// Parse multipart body
+// Helper to detect if a string contains binary data
+function isBinaryData(str) {
+  // Check first 100 chars for binary indicators
+  for (var i = 0; i < Math.min(str.length, 100); i++) {
+    var code = str.charCodeAt(i);
+    // Non-printable chars (except CR/LF/TAB)
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13) return true;
+    // High byte range that's not valid text
+    if (code > 126 && code < 160) return true;
+    // Null byte is definitely binary
+    if (code === 0) return true;
+  }
+  return false;
+}
+
+// Parse multipart body - handles binary data in headers
 function parseMultipart(contentType, body) {
   var boundaryMatch = contentType.match(/boundary="?([^";\s]+)"?/);
   if (!boundaryMatch) return {};
@@ -350,8 +366,8 @@ function parseMultipart(contentType, body) {
   var boundaryDelim = "--".concat(boundary);
   var endBoundary = "--".concat(boundary, "--");
 
-  // Remove the final boundary terminator if present
-  var bodyContent = body;
+  // Use binary encoding to preserve all bytes as character codes 0-255
+  var bodyContent = typeof body === "string" ? body : body.toString("binary");
   if (bodyContent.endsWith(endBoundary)) {
     bodyContent = bodyContent.substring(0, bodyContent.lastIndexOf(endBoundary));
   }
@@ -365,59 +381,137 @@ function parseMultipart(contentType, body) {
   try {
     for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
       var part = _step3.value;
-      var _part$split = part.split(DOUBLE_CRLF),
-        _part$split2 = _toArray(_part$split),
-        headerBlock = _part$split2[0],
-        bodyParts = _part$split2.slice(1);
-      var partBody = bodyParts.join(DOUBLE_CRLF);
-
-      // Remove trailing CRLF
-      partBody = partBody.replace(/\r?\n?$/, "");
+      // First split to find the headers/body boundary (double CRLF)
+      var headerBodySplit = part.indexOf(DOUBLE_CRLF);
+      var headerBlock = void 0,
+        partBody = void 0;
+      if (headerBodySplit !== -1) {
+        headerBlock = part.substring(0, headerBodySplit);
+        partBody = part.substring(headerBodySplit + DOUBLE_CRLF.length);
+        // Remove trailing CRLF from body
+        partBody = partBody.replace(/\r?\n?$/, "");
+      } else {
+        headerBlock = part;
+        partBody = "";
+      }
       var headers = {};
-      var headerLines = headerBlock.split(/\r?\n/);
-      var _iterator4 = _createForOfIteratorHelper(headerLines),
-        _step4;
-      try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          var line = _step4.value;
-          var colonIndex = line.indexOf(": ");
-          if (colonIndex > 0) {
-            var name = line.substring(0, colonIndex).toLowerCase();
-            var value = line.substring(colonIndex + 2);
-            headers[name] = value;
+
+      // Parse headers more carefully to handle binary data
+      var currentPos = 0;
+      while (currentPos < headerBlock.length) {
+        // Find next line ending (but be careful with binary data)
+        var lineEnd = headerBlock.indexOf("\r\n", currentPos);
+        if (lineEnd === -1) lineEnd = headerBlock.indexOf("\n", currentPos);
+        if (lineEnd === -1) lineEnd = headerBlock.length;
+        var line = headerBlock.substring(currentPos, lineEnd);
+        var colonIndex = line.indexOf(": ");
+        if (colonIndex > 0) {
+          var name = line.substring(0, colonIndex).toLowerCase();
+          var value = line.substring(colonIndex + 2);
+
+          // Special handling for known binary fields or detected binary data
+          if (name === "owner" || name === "signature") {
+            // These fields contain binary data that may have embedded newlines
+            // We need to read until we find the next header or end of headers
+            var valueStart = currentPos + colonIndex + 2;
+
+            // Look ahead to find where this field really ends
+            // The next header will start with a valid header name followed by ": "
+            var searchPos = valueStart;
+            var valueEnd = headerBlock.length;
+
+            // Look for the next valid header pattern
+            while (searchPos < headerBlock.length) {
+              var nextNewline = headerBlock.indexOf("\n", searchPos);
+              if (nextNewline === -1) break;
+
+              // Check if what follows looks like a header
+              var nextLineStart = nextNewline + 1;
+              var nextColon = headerBlock.indexOf(":", nextLineStart);
+
+              // Valid header should have colon relatively close to line start
+              if (nextColon > nextLineStart && nextColon < nextLineStart + 50) {
+                // Check if the text before colon looks like a header name (ASCII text)
+                var possibleHeaderName = headerBlock.substring(nextLineStart, nextColon);
+                var looksLikeHeader = /^[a-zA-Z0-9-]+$/.test(possibleHeaderName);
+                if (looksLikeHeader) {
+                  // Found the next header, value ends at the newline before it
+                  valueEnd = nextNewline;
+                  break;
+                }
+              }
+              searchPos = nextNewline + 1;
+            }
+
+            // Extract the full value, trimming any trailing whitespace
+            value = headerBlock.substring(valueStart, valueEnd);
+
+            // Remove trailing CR if present (since we found the LF)
+            if (value.endsWith("\r")) {
+              value = value.substring(0, value.length - 1);
+            }
+
+            // Convert to Buffer to preserve binary
+            headers[name] = Buffer.from(value, "binary");
+            currentPos = valueEnd + 1;
+          } else {
+            // Regular text field
+            if (isBinaryData(value)) {
+              headers[name] = Buffer.from(value, "binary");
+            } else {
+              headers[name] = value;
+            }
+            currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1);
           }
+        } else {
+          // No colon found, skip this line
+          currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1);
         }
-      } catch (err) {
-        _iterator4.e(err);
-      } finally {
-        _iterator4.f();
       }
       var disposition = headers["content-disposition"];
       if (!disposition) continue;
       var partName = void 0;
       if (disposition === "inline") {
+        // This is the inline part
         partName = "body";
         bodyKeysList.push("body");
+
+        // Extract all headers from inline part as top-level fields
+        var restHeaders = _objectSpread({}, headers);
+        delete restHeaders["content-disposition"];
+
+        // Add each header from the inline part to the top level of result
+        for (var _i8 = 0, _Object$entries8 = Object.entries(restHeaders); _i8 < _Object$entries8.length; _i8++) {
+          var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i8], 2),
+            key = _Object$entries8$_i[0],
+            _value2 = _Object$entries8$_i[1];
+          result[key] = _value2;
+        }
+
+        // If there's body content in the inline part, add it as 'body'
+        if (partBody) {
+          result[partName] = partBody;
+        }
       } else {
+        // Handle named form-data parts
         var nameMatch = disposition.match(/name="([^"]+)"/);
         partName = nameMatch ? nameMatch[1] : null;
         if (partName) {
-          // Add the top-level key for this part
           var topLevelKey = partName.split("/")[0];
           bodyKeysList.push(topLevelKey);
         }
-      }
-      if (!partName) continue;
-      var restHeaders = _objectSpread({}, headers);
-      delete restHeaders["content-disposition"];
-      if (Object.keys(restHeaders).length === 0) {
-        result[partName] = partBody;
-      } else if (!partBody) {
-        result[partName] = restHeaders;
-      } else {
-        result[partName] = _objectSpread(_objectSpread({}, restHeaders), {}, {
-          body: partBody
-        });
+        if (!partName) continue;
+        var _restHeaders = _objectSpread({}, headers);
+        delete _restHeaders["content-disposition"];
+        if (Object.keys(_restHeaders).length === 0) {
+          result[partName] = partBody;
+        } else if (!partBody) {
+          result[partName] = _restHeaders;
+        } else {
+          result[partName] = _objectSpread(_objectSpread({}, _restHeaders), {}, {
+            body: partBody
+          });
+        }
       }
     }
   } catch (err) {
@@ -426,7 +520,6 @@ function parseMultipart(contentType, body) {
     _iterator3.f();
   }
   if (bodyKeysList.length > 0) {
-    // Format as structured field list, preserving order and duplicates
     result["body-keys"] = bodyKeysList.map(function (k) {
       return "\"".concat(k, "\"");
     }).join(", ");
@@ -492,10 +585,10 @@ function httpsig_from(http) {
 
     // Convert flat structure to nested using flat.js
     var flat = {};
-    for (var _i8 = 0, _Object$entries8 = Object.entries(withBodyKeys); _i8 < _Object$entries8.length; _i8++) {
-      var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i8], 2),
-        key = _Object$entries8$_i[0],
-        value = _Object$entries8$_i[1];
+    for (var _i9 = 0, _Object$entries9 = Object.entries(withBodyKeys); _i9 < _Object$entries9.length; _i9++) {
+      var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i9], 2),
+        key = _Object$entries9$_i[0],
+        value = _Object$entries9$_i[1];
       if (key.includes("/")) {
         flat[key] = value;
       }
@@ -503,14 +596,14 @@ function httpsig_from(http) {
     if (Object.keys(flat).length > 0) {
       // Use flat_from to convert flat structure to nested
       var nested = (0, _flat.flat_from)(flat);
-      for (var _i9 = 0, _Object$entries9 = Object.entries(nested); _i9 < _Object$entries9.length; _i9++) {
-        var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i9], 2),
-          _key2 = _Object$entries9$_i[0],
-          _value2 = _Object$entries9$_i[1];
-        withBodyKeys[_key2] = _value2;
+      for (var _i0 = 0, _Object$entries0 = Object.entries(nested); _i0 < _Object$entries0.length; _i0++) {
+        var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i0], 2),
+          _key2 = _Object$entries0$_i[0],
+          _value3 = _Object$entries0$_i[1];
+        withBodyKeys[_key2] = _value3;
       }
-      for (var _i0 = 0, _Object$keys = Object.keys(flat); _i0 < _Object$keys.length; _i0++) {
-        var _key3 = _Object$keys[_i0];
+      for (var _i1 = 0, _Object$keys = Object.keys(flat); _i1 < _Object$keys.length; _i1++) {
+        var _key3 = _Object$keys[_i1];
         delete withBodyKeys[_key3];
       }
     }
@@ -529,8 +622,8 @@ function httpsig_from(http) {
   delete result["content-digest"];
 
   // Extract hashpaths if any
-  for (var _i1 = 0, _Object$keys2 = Object.keys(result); _i1 < _Object$keys2.length; _i1++) {
-    var _key4 = _Object$keys2[_i1];
+  for (var _i10 = 0, _Object$keys2 = Object.keys(result); _i10 < _Object$keys2.length; _i10++) {
+    var _key4 = _Object$keys2[_i10];
     if (_key4.startsWith("hashpath")) {
       delete result[_key4];
     }
@@ -570,10 +663,10 @@ function httpsig_to(tabm) {
     // For flat structures, just return with normalized keys
     // This matches Erlang which returns the map unchanged
     var result = _objectSpread({}, inlineFieldHdrs);
-    for (var _i10 = 0, _Object$entries0 = Object.entries(stripped); _i10 < _Object$entries0.length; _i10++) {
-      var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i10], 2),
-        key = _Object$entries0$_i[0],
-        value = _Object$entries0$_i[1];
+    for (var _i11 = 0, _Object$entries1 = Object.entries(stripped); _i11 < _Object$entries1.length; _i11++) {
+      var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i11], 2),
+        key = _Object$entries1$_i[0],
+        value = _Object$entries1$_i[1];
       // Convert Buffers to strings if they're UTF-8 text
       if (Buffer.isBuffer(value)) {
         try {
@@ -623,31 +716,31 @@ function httpsig_to(tabm) {
   var headers = _objectSpread({}, inlineFieldHdrs);
 
   // Process each field - ao-types at top level should go to headers
-  for (var _i11 = 0, _Object$entries1 = Object.entries(stripped); _i11 < _Object$entries1.length; _i11++) {
-    var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i11], 2),
-      _key5 = _Object$entries1$_i[0],
-      _value3 = _Object$entries1$_i[1];
+  for (var _i12 = 0, _Object$entries10 = Object.entries(stripped); _i12 < _Object$entries10.length; _i12++) {
+    var _Object$entries10$_i = _slicedToArray(_Object$entries10[_i12], 2),
+      _key5 = _Object$entries10$_i[0],
+      _value4 = _Object$entries10$_i[1];
     if (_key5 === "ao-types") {
       // Top-level ao-types goes to headers only
       // Convert Buffer to string if needed
-      if (Buffer.isBuffer(_value3)) {
-        headers[_key5] = _value3.toString("utf8");
+      if (Buffer.isBuffer(_value4)) {
+        headers[_key5] = _value4.toString("utf8");
       } else {
-        headers[_key5] = _value3;
+        headers[_key5] = _value4;
       }
     } else if (_key5 === "body" || _key5 === inlineKeyVal) {
-      bodyMap[_key5 === inlineKeyVal ? inlineKeyVal : "body"] = _value3;
-    } else if (_typeof(_value3) === "object" && _value3 !== null && !Array.isArray(_value3) && !Buffer.isBuffer(_value3)) {
-      bodyMap[_key5] = _value3;
-    } else if (typeof _value3 === "string" && _value3.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
-      headers[normalizeKey(_key5)] = _value3;
-    } else if (Buffer.isBuffer(_value3) && _value3.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
+      bodyMap[_key5 === inlineKeyVal ? inlineKeyVal : "body"] = _value4;
+    } else if (_typeof(_value4) === "object" && _value4 !== null && !Array.isArray(_value4) && !Buffer.isBuffer(_value4)) {
+      bodyMap[_key5] = _value4;
+    } else if (typeof _value4 === "string" && _value4.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
+      headers[normalizeKey(_key5)] = _value4;
+    } else if (Buffer.isBuffer(_value4) && _value4.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
       // Convert Buffers to strings for headers
-      var _str = _value3.toString("utf8");
+      var _str = _value4.toString("utf8");
       headers[normalizeKey(_key5)] = _str;
     } else if (_key5 !== "ao-types") {
       // Only add to bodyMap if it's not ao-types
-      bodyMap[_key5] = _value3;
+      bodyMap[_key5] = _value4;
     }
   }
 
@@ -671,22 +764,22 @@ function httpsig_to(tabm) {
         b = _ref8[0];
       return a.localeCompare(b);
     });
-    var _iterator5 = _createForOfIteratorHelper(sortedEntries),
-      _step5;
+    var _iterator4 = _createForOfIteratorHelper(sortedEntries),
+      _step4;
     try {
-      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-        var _step5$value = _slicedToArray(_step5.value, 2),
-          _key6 = _step5$value[0],
-          _value4 = _step5$value[1];
-        if (_typeof(_value4) === "object" && _value4 !== null && Object.keys(_value4).length === 1 && "body" in _value4) {
-          var encoded = encodeBodyPart("".concat(_key6, "/body"), _value4, "body");
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _step4$value = _slicedToArray(_step4.value, 2),
+          _key6 = _step4$value[0],
+          _value5 = _step4$value[1];
+        if (_typeof(_value5) === "object" && _value5 !== null && Object.keys(_value5).length === 1 && "body" in _value5) {
+          var encoded = encodeBodyPart("".concat(_key6, "/body"), _value5, "body");
           parts.push({
             name: "".concat(_key6, "/body"),
             body: encoded
           });
           bodyKeysList.push(_key6);
         } else {
-          var _encoded = encodeBodyPart(_key6, _value4, inlineKeyVal);
+          var _encoded = encodeBodyPart(_key6, _value5, inlineKeyVal);
           parts.push({
             name: _key6,
             body: _encoded
@@ -695,9 +788,9 @@ function httpsig_to(tabm) {
         }
       }
     } catch (err) {
-      _iterator5.e(err);
+      _iterator4.e(err);
     } finally {
-      _iterator5.f();
+      _iterator4.f();
     }
     var boundary = boundaryFromParts(parts);
     var bodyParts = parts.map(function (p) {
@@ -713,4 +806,18 @@ function httpsig_to(tabm) {
     });
     return addContentDigest(_result2);
   }
+}
+
+/**
+ * Convert structured message to flat format
+ */
+function structured_to(msg) {
+  return msg;
+}
+
+/**
+ * Convert flat format to structured message
+ */
+function structured_from(msg) {
+  return msg;
 }