Parse trailing LWSP after multipart boundary delimiter (#17)

Author: zefir-git

src/Component.ts

@@ -22,7 +22,7 @@ export class Component implements Part {
      * @param data Component byte representation to parse
      */
     public static parse(data: Uint8Array): Component {
-        const hasHeaders = Multipart.findSequenceIndex(data, Multipart.CRLF) !== 0;
+        const hasHeaders = !(data[0] === Multipart.CR && data[1] === Multipart.LF);
         const headersEndIndex = hasHeaders ? Multipart.findSequenceIndex(data, Multipart.combineArrays([Multipart.CRLF, Multipart.CRLF])) + 2 : 0;
 
         const headersBuffer = data.slice(0, headersEndIndex);

src/Multipart.ts

@@ -181,23 +181,23 @@ export class Multipart implements Part {
             console.warn("Invalid boundary:", new TextDecoder().decode(boundary), "\nMust be 1 to 70 characters long, not end with space, and may only contain: A-Z a-z 0-9 '()+_,-./:=? and space");
 
         const parts: Uint8Array[] = [];
-        const fullBoundarySequence = new Uint8Array(Multipart.combineArrays([Multipart.DOUBLE_DASH, boundary, Multipart.CRLF]));
-        const endBoundarySequence = new Uint8Array(Multipart.combineArrays([Multipart.DOUBLE_DASH, boundary, Multipart.DOUBLE_DASH, Multipart.CRLF]));
 
-        let start = 0;
-        while (true) {
-            const boundaryIndex = Multipart.findSequenceIndex(data, fullBoundarySequence, start);
-            if (boundaryIndex === -1) break;
-
-            const partStart = boundaryIndex + fullBoundarySequence.length;
-            const nextBoundaryIndex = Multipart.findSequenceIndex(data, fullBoundarySequence, partStart);
-            const endBoundaryIndex = Multipart.findSequenceIndex(data, endBoundarySequence, partStart);
+        // add artificial CRLF at the start of the data
+        const paddedData = Multipart.combineArrays([Multipart.CRLF, data]);
+        const closingBoundaryDelimiter = Multipart.combineArrays([boundary, Multipart.DOUBLE_DASH]);
 
-            // -2 to ignore the mandatory CRLF at the end of the body
-            const partEnd = nextBoundaryIndex === -1 ? (endBoundaryIndex === -1 ? data.length : endBoundaryIndex - 2) : nextBoundaryIndex - 2;
-
-            if (partStart < partEnd) parts.push(data.slice(partStart, partEnd));
-            start = partEnd;
+        let start = 0;
+        while (start < paddedData.length) {
+            const boundaryIndices = Multipart.findBoundaryBounds(paddedData, boundary, start);
+            if (boundaryIndices === null) break;
+            const [, boundaryEnd] = boundaryIndices;
+            const nextBoundaryIndices =
+                Multipart.findBoundaryBounds(paddedData, boundary, boundaryEnd + 1)
+                ?? Multipart.findBoundaryBounds(paddedData, closingBoundaryDelimiter, boundaryEnd + 1);
+            if (nextBoundaryIndices === null) break;
+            const [nextBoundaryStart] = nextBoundaryIndices;
+            parts.push(paddedData.slice(boundaryEnd, nextBoundaryStart));
+            start = nextBoundaryStart;
         }
 
         const parsedParts = parts.map(Component.parse);
@@ -267,6 +267,35 @@ export class Multipart implements Part {
         return -1;
     }
 
+    /**
+     * Find boundary delimiter start and end index
+     * @param data Multipart body bytes
+     * @param boundary The multipart boundary bytes
+     * @param [start] The index to start the search at (i.e. the number of bytes to skip/ignore at the beginning of the byte array). Defaults to 0.
+     * @returns The start and end index of the boundary delimiter, or `null` if no boundary delimiter can be found
+     * @internal
+     */
+    private static findBoundaryBounds(data: Uint8Array, boundary: Uint8Array, start = 0): [number, number] | null {
+        if (start >= data.length) return null;
+        const boundaryStartIndex = Multipart.findSequenceIndex(data, Multipart.combineArrays([Multipart.CRLF, Multipart.DOUBLE_DASH, boundary]), start);
+        if (boundaryStartIndex === -1) return null;
+        let currentEndOfBoundaryIndex = boundaryStartIndex + boundary.length + 4;
+        while (currentEndOfBoundaryIndex < data.length) {
+            const byte = data[currentEndOfBoundaryIndex];
+            if (byte === Multipart.CR && data[currentEndOfBoundaryIndex + 1] === Multipart.LF)
+                return [boundaryStartIndex, currentEndOfBoundaryIndex + 2];
+            if (byte === Multipart.SP || byte === 0x09) {
+                currentEndOfBoundaryIndex++;
+                continue;
+            }
+            // encountered non-linear whitespace after boundary and before any CRLF
+            // meaning the boundary could not be terminated, therefore continue search for boundary
+            return Multipart.findBoundaryBounds(data, boundary, boundaryStartIndex + 2);
+        }
+
+        return null;
+    }
+
     /**
      * Parse header params in the format `key=value;foo = "bar"; baz`
      */

test/Multipart.test.js

@@ -128,6 +128,93 @@ describe("Multipart", function () {
             expect(parsedMultipart).to.be.an.instanceof(Multipart);
             expect(parsedMultipart.parts).to.be.empty;
         });
+
+        it("should parse Multipart from empty Component bytes", function () {
+            const multipart = new Multipart([new Component({})]);
+            const multipartBytes = multipart.bytes();
+            const parsedMultipart = Multipart.parse(multipartBytes);
+            expect(parsedMultipart).to.be.an.instanceof(Multipart);
+            expect(parsedMultipart.parts.length).to.equal(1);
+            const part = parsedMultipart.parts[0];
+            expect(part.bytes()).to.deep.equal(Multipart.CRLF);
+            expect(part.headers).to.be.empty;
+            expect(part.body).to.be.empty;
+        });
+
+        it("should handle parsing of empty parts in multipart MIME string", function () {
+            const string = "Content-type: multipart/mixed; boundary=\"simple boundary\"\r\n\r\n"
+                + "--simple boundary\r\n"
+                + "\r\n"
+                + "\r\n"
+                + "--simple boundary--\r\n";
+            const multipart = Multipart.parse(new TextEncoder().encode(string));
+            const multipartBytes = multipart.bytes();
+            const parsedMultipart = Multipart.parse(multipartBytes);
+            expect(parsedMultipart).to.be.an.instanceof(Multipart);
+            expect(parsedMultipart.parts.length).to.equal(1);
+            const part = parsedMultipart.parts[0];
+            expect(part.bytes()).to.deep.equal(Multipart.CRLF);
+            expect(part.headers).to.be.empty;
+            expect(part.body).to.be.empty;
+        });
+
+        it("should ignore linear whitespace after boundary delimiter", function () {
+            const string =
+                '--simple boundary    \r\n' +
+                'X-Foo: Bar\r\n' +
+                '\r\n' +
+                'The boundary delimiter of this part has trailing SP.\r\n' +
+                '--simple boundary\t\t\r\n' +
+                'X-Foo: Baz\r\n' +
+                '\r\n' +
+                'The boundary delimiter of this part has trailing tab.\r\n' +
+                '--simple boundary  \t\t\ \r\n' +
+                'X-Foo: Foo\r\n' +
+                '\r\n' +
+                'The boundary delimiter of this part has trailing SP and tab.\r\n' +
+                '--simple boundary--\t \t\r\n'
+
+            const parsedMultipart = Multipart.parseBody(new TextEncoder().encode(string), new TextEncoder().encode("simple boundary"));
+
+            expect(parsedMultipart).to.be.an.instanceof(Multipart);
+            expect(parsedMultipart.parts.length).to.equal(3);
+            const part1 = parsedMultipart.parts[0];
+            expect(part1.headers.get("x-foo")).to.equal("Bar");
+            expect(new TextDecoder().decode(part1.body)).to.equal("The boundary delimiter of this part has trailing SP.");
+            const part2 = parsedMultipart.parts[1];
+            expect(part2.headers.get("x-foo")).to.equal("Baz");
+            expect(new TextDecoder().decode(part2.body)).to.equal("The boundary delimiter of this part has trailing tab.");
+            const part3 = parsedMultipart.parts[2];
+            expect(part3.headers.get("x-foo")).to.equal("Foo");
+            expect(new TextDecoder().decode(part3.body)).to.equal("The boundary delimiter of this part has trailing SP and tab.");
+        });
+
+        it("should handle strings that look like part boundary", function () {
+            const string =
+                '--simple boundary\r\n' +
+                'X-Foo: Bar\r\n' +
+                '\r\n' +
+                'Can this handle\r\n' +
+                '--simple boundary this is fake\r\n' +
+                '\r\n' +
+                'not new part\r\n' +
+                '--simple boundary\r\n' +
+                'X-Foo: Baz\r\n' +
+                '\r\n' +
+                'Final part\r\n' +
+                '--simple boundary--\r\n'
+
+            const parsedMultipart = Multipart.parseBody(new TextEncoder().encode(string), new TextEncoder().encode("simple boundary"));
+
+            expect(parsedMultipart).to.be.an.instanceof(Multipart);
+            expect(parsedMultipart.parts.length).to.equal(2);
+            const part1 = parsedMultipart.parts[0];
+            expect(part1.headers.get("x-foo")).to.equal("Bar");
+            expect(new TextDecoder().decode(part1.body)).to.equal("Can this handle\r\n--simple boundary this is fake\r\n\r\nnot new part");
+            const part2 = parsedMultipart.parts[1];
+            expect(part2.headers.get("x-foo")).to.equal("Baz");
+            expect(new TextDecoder().decode(part2.body)).to.equal("Final part");
+        });
     });
 
     describe("formData", function () {