@atproto/xrpc-server 0.6.4 → 0.7.1

package/src/util.ts

@@ -1,7 +1,6 @@
 import assert from 'node:assert'
-import { Duplex, PassThrough, pipeline, Readable } from 'node:stream'
+import { Duplex, pipeline, Readable } from 'node:stream'
 import { IncomingMessage } from 'node:http'
-import * as zlib from 'node:zlib'
 import express from 'express'
 import mime from 'mime-types'
 import {
@@ -11,7 +10,7 @@ import {
   LexXrpcQuery,
   LexXrpcSubscription,
 } from '@atproto/lexicon'
-import { MaxSizeChecker } from '@atproto/common'
+import { createDecoders, MaxSizeChecker } from '@atproto/common'
 import { ResponseType } from '@atproto/xrpc'
 
 import {
@@ -157,7 +156,7 @@ export function validateOutput(
   def: LexXrpcProcedure | LexXrpcQuery,
   output: HandlerSuccess | undefined,
   lexicons: Lexicons,
-): HandlerSuccess | undefined {
+): void {
   // initial validation
   if (output) {
     handlerSuccess.parse(output)
@@ -197,8 +196,6 @@ export function validateOutput(
       throw new InternalServerError(e instanceof Error ? e.message : String(e))
     }
   }
-
-  return output
 }
 
 export function normalizeMime(v: string) {
@@ -261,7 +258,17 @@ function decodeBodyStream(
     )
   }
 
-  const transforms: Duplex[] = createDecoders(contentEncoding)
+  let transforms: Duplex[]
+  try {
+    transforms = createDecoders(contentEncoding)
+  } catch (cause) {
+    throw new XRPCError(
+      ResponseType.UnsupportedMediaType,
+      'unsupported content-encoding',
+      undefined,
+      { cause },
+    )
+  }
 
   if (maxSize !== undefined) {
     const maxSizeChecker = new MaxSizeChecker(
@@ -277,54 +284,6 @@ function decodeBodyStream(
     : req
 }
 
-export function createDecoders(contentEncoding?: string | string[]): Duplex[] {
-  return parseContentEncoding(contentEncoding).reverse().map(createDecoder)
-}
-
-export function parseContentEncoding(
-  contentEncoding?: string | string[],
-): string[] {
-  // undefined, empty string, and empty array
-  if (!contentEncoding?.length) return []
-
-  // Non empty string
-  if (typeof contentEncoding === 'string') {
-    return contentEncoding
-      .split(',')
-      .map((x) => x.trim().toLowerCase())
-      .filter((x) => x && x !== 'identity')
-  }
-
-  // content-encoding should never be an array
-  return contentEncoding.flatMap(parseContentEncoding)
-}
-
-export function createDecoder(encoding: string): Duplex {
-  // https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1
-  // > All content-coding values are case-insensitive...
-  switch (encoding.trim().toLowerCase()) {
-    // https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2
-    case 'gzip':
-    case 'x-gzip':
-      return zlib.createGunzip({
-        // using Z_SYNC_FLUSH (cURL default) to be less strict when decoding
-        flush: zlib.constants.Z_SYNC_FLUSH,
-        finishFlush: zlib.constants.Z_SYNC_FLUSH,
-      })
-    case 'deflate':
-      return zlib.createInflate()
-    case 'br':
-      return zlib.createBrotliDecompress()
-    case 'identity':
-      return new PassThrough()
-    default:
-      throw new XRPCError(
-        ResponseType.UnsupportedMediaType,
-        'unsupported content-encoding',
-      )
-  }
-}
-
 export function serverTimingHeader(timings: ServerTiming[]) {
   return timings
     .map((timing) => {
@@ -360,11 +319,70 @@ export interface ServerTiming {
   description?: string
 }
 
-export const parseReqNsid = (
-  req: express.Request | IncomingMessage,
-): string => {
-  const originalUrl =
-    ('originalUrl' in req && req.originalUrl) || req.url || '/'
-  const nsid = originalUrl.split('?')[0].replace('/xrpc/', '')
-  return nsid.endsWith('/') ? nsid.slice(0, -1) : nsid // trim trailing slash
+export const parseReqNsid = (req: express.Request | IncomingMessage) =>
+  parseUrlNsid('originalUrl' in req ? req.originalUrl : req.url || '/')
+
+/**
+ * Validates and extracts the nsid from an xrpc path
+ */
+export const parseUrlNsid = (url: string): string => {
+  // /!\ Hot path
+
+  if (
+    // Ordered by likelihood of failure
+    url.length <= 6 ||
+    url[5] !== '/' ||
+    url[4] !== 'c' ||
+    url[3] !== 'p' ||
+    url[2] !== 'r' ||
+    url[1] !== 'x' ||
+    url[0] !== '/'
+  ) {
+    throw new InvalidRequestError('invalid xrpc path')
+  }
+
+  const startOfNsid = 6
+
+  let curr = startOfNsid
+  let char: number
+  let alphaNumRequired = true
+  for (; curr < url.length; curr++) {
+    char = url.charCodeAt(curr)
+    if (
+      (char >= 48 && char <= 57) || // 0-9
+      (char >= 65 && char <= 90) || // A-Z
+      (char >= 97 && char <= 122) // a-z
+    ) {
+      alphaNumRequired = false
+    } else if (char === 45 /* "-" */ || char === 46 /* "." */) {
+      if (alphaNumRequired) {
+        throw new InvalidRequestError('invalid xrpc path')
+      }
+      alphaNumRequired = true
+    } else if (char === 47 /* "/" */) {
+      // Allow trailing slash (next char is either EOS or "?")
+      if (curr === url.length - 1 || url.charCodeAt(curr + 1) === 63) {
+        break
+      }
+      throw new InvalidRequestError('invalid xrpc path')
+    } else if (char === 63 /* "?"" */) {
+      break
+    } else {
+      throw new InvalidRequestError('invalid xrpc path')
+    }
+  }
+
+  // last char was one of: '-', '.', '/'
+  if (alphaNumRequired) {
+    throw new InvalidRequestError('invalid xrpc path')
+  }
+
+  // A domain name consists of minimum two characters
+  if (curr - startOfNsid < 2) {
+    throw new InvalidRequestError('invalid xrpc path')
+  }
+
+  // @TODO is there a max ?
+
+  return url.slice(startOfNsid, curr)
 }

package/tests/parsing.test.ts

@@ -0,0 +1,89 @@
+import { parseUrlNsid } from '../src/util'
+
+const testValid = (url: string, expected: string) => {
+  expect(parseUrlNsid(url)).toBe(expected)
+}
+
+const testInvalid = (url: string, errorMessage = 'invalid xrpc path') => {
+  expect(() => parseUrlNsid(url)).toThrow(errorMessage)
+}
+
+describe('parseUrlNsid', () => {
+  it('should extract the NSID from the URL', () => {
+    testValid('/xrpc/blee.blah.bloo', 'blee.blah.bloo')
+    testValid('/xrpc/blee.blah.bloo?foo[]', 'blee.blah.bloo')
+    testValid('/xrpc/blee.blah.bloo?foo=bar', 'blee.blah.bloo')
+    testValid('/xrpc/com.example.nsid', 'com.example.nsid')
+    testValid('/xrpc/com.example.nsid?foo=bar', 'com.example.nsid')
+    testValid('/xrpc/com.example-domain.nsid', 'com.example-domain.nsid')
+  })
+
+  it('should allow a trailing slash', () => {
+    testValid('/xrpc/blee.blah.bloo/?', 'blee.blah.bloo')
+    testValid('/xrpc/blee.blah.bloo/?foo=', 'blee.blah.bloo')
+    testValid('/xrpc/blee.blah.bloo/?bool', 'blee.blah.bloo')
+    testValid('/xrpc/com.example.nsid/', 'com.example.nsid')
+  })
+
+  it('should throw an error if the URL is too short', () => {
+    testInvalid('/xrpc/a')
+  })
+
+  it('should throw an error if the URL is empty', () => {
+    testInvalid('')
+  })
+
+  it('should throw an error if the URL is missing the NSID', () => {
+    testInvalid('/xrpc/')
+    testInvalid('/xrpc/?')
+    testInvalid('/xrpc/?foo=bar')
+  })
+
+  it('should throw an error if the URL contains extra path segments', () => {
+    testInvalid('/xrpc/123/extra')
+    testInvalid('/xrpc/123/extra?foo=bar')
+  })
+
+  it('should throw an error if the URL is missing the XRPC path prefix', () => {
+    testInvalid('/foo/123')
+    testInvalid('/foo/com.example.nsid')
+  })
+
+  it('should throw an error if the NSID starts with a dot', () => {
+    testInvalid('/xrpc/.')
+    testInvalid('/xrpc/..')
+    testInvalid('/xrpc/....')
+    testInvalid('/xrpc/.com.example.nsid')
+    testInvalid('/xrpc/com..example.nsid')
+    testInvalid('/xrpc/com.example..nsid')
+    testInvalid('/xrpc/com.example.nsid.')
+    testInvalid('/xrpc/com.example.nsid./')
+    testInvalid('/xrpc/com.example.nsid.?foo=bar')
+    testInvalid('/xrpc/com.example.nsid./?foo=bar')
+  })
+
+  it('should throw an error if the NSID contains a misplaced dash', () => {
+    testInvalid('/xrpc/-')
+    testInvalid('/xrpc/com.example.-nsid')
+    testInvalid('/xrpc/com.example-.nsid')
+    testInvalid('/xrpc/com.-example.nsid')
+    testInvalid('/xrpc/com.-example-.nsid')
+    testInvalid('/xrpc/com.example.nsid-')
+    testInvalid('/xrpc/-com.example.nsid')
+    testInvalid('/xrpc/com.example--domain.nsid')
+  })
+
+  it('should throw an error if the URL starts with a space', () => {
+    testInvalid(' /xrpc/com.example.nsid')
+  })
+
+  it('should throw an error if the NSID contains invalid characters', () => {
+    testInvalid('/xrpc/com.example.nsid#')
+    testInvalid('/xrpc/com.example.nsid!')
+    testInvalid('/xrpc/com.example#?nsid')
+    testInvalid('/xrpc/!com.example.nsid')
+    testInvalid('/xrpc/com.example.nsid ')
+    testInvalid('/xrpc/ com.example.nsid')
+    testInvalid('/xrpc/com. example.nsid')
+  })
+})