@evanp/activitypub-bot 0.36.2 → 0.37.1

package/lib/app.js

@@ -44,6 +44,7 @@ import DoNothingBot from './bots/donothing.js'
 import { FanoutWorker } from './fanoutworker.js'
 import { IntakeWorker } from './intakeworker.js'
 import { RemoteObjectCache } from './remoteobjectcache.js'
+import { HTTPMessageSignature } from './httpmessagesignature.js'
 
 const currentDir = dirname(fileURLToPath(import.meta.url))
 const DEFAULT_INDEX_FILENAME = resolve(currentDir, '..', 'web', 'index.html')
@@ -66,6 +67,7 @@ export async function makeApp ({ databaseUrl, origin, bots, logLevel = 'silent',
   await runMigrations(connection)
   const formatter = new UrlFormatter(origin)
   const signer = new HTTPSignature(logger)
+  const messageSigner = new HTTPMessageSignature(logger)
   const digester = new Digester(logger)
   const actorStorage = new ActorStorage(connection, formatter)
   const botDataStorage = new BotDataStorage(connection)
@@ -75,7 +77,7 @@ export async function makeApp ({ databaseUrl, origin, bots, logLevel = 'silent',
   const remoteObjectCache = new RemoteObjectCache(connection, logger)
   const client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger, limiter, remoteObjectCache)
   const remoteKeyStorage = new RemoteKeyStorage(client, connection, logger)
-  const signature = new HTTPSignatureAuthenticator(remoteKeyStorage, signer, digester, logger)
+  const signature = new HTTPSignatureAuthenticator(remoteKeyStorage, signer, messageSigner, digester, logger)
   const jobQueue = new JobQueue(connection, logger)
   const distributor = new ActivityDistributor(
     client,

package/lib/digester.js

@@ -12,6 +12,12 @@ export class Digester {
     return `sha-256=${digest.digest('base64')}`
   }
 
+  async contentDigest (body) {
+    const digest = crypto.createHash('sha256')
+    digest.update(body)
+    return `sha-256=:${digest.digest('base64')}:`
+  }
+
   equals (digest1, digest2) {
     const [alg1, hash1] = digest1.split('=', 2)
     const [alg2, hash2] = digest2.split('=', 2)

package/lib/httpmessagesignature.js

@@ -0,0 +1,212 @@
+import assert from 'node:assert'
+import crypto from 'node:crypto'
+
+export class HTTPMessageSignature {
+  static #preferredAlgs = [
+    'ecdsa-p384-sha384',
+    'ecdsa-p256-sha256',
+    'rsa-pss-sha512',
+    'rsa-pss-sha256',
+    'rsa-v1_5-sha256'
+  ]
+
+  #logger
+
+  constructor (logger) {
+    assert.ok(logger)
+    assert.strictEqual(typeof logger, 'object')
+    this.#logger = logger
+  }
+
+  keyId (signatureInput) {
+    assert.ok(signatureInput)
+    assert.strictEqual(typeof signatureInput, 'string')
+    const inputs = this.#parseSignatureInput(signatureInput)
+    const input = this.#bestInput(inputs)
+    return (input)
+      ? input.keyid
+      : null
+  }
+
+  created (signatureInput) {
+    assert.ok(signatureInput)
+    assert.strictEqual(typeof signatureInput, 'string')
+    const inputs = this.#parseSignatureInput(signatureInput)
+    const input = this.#bestInput(inputs)
+    return (input)
+      ? input.created
+      : null
+  }
+
+  async sign ({ privateKey, keyId, url, method, headers }) {
+    const parsed = new URL(url)
+
+    const signatureInput = []
+
+    signatureInput.push(['@method', method.toUpperCase()])
+    signatureInput.push(['@authority', parsed.host])
+    signatureInput.push(['@path', parsed.pathname])
+    if (parsed.search) {
+      signatureInput.push(['@query', parsed.search])
+    }
+
+    for (const name in headers) {
+      const lcname = name.toLowerCase()
+      signatureInput.push([lcname, headers[name]])
+    }
+
+    const created = Math.floor(Date.now() / 1000)
+    const componentList = signatureInput.map(([name]) => `"${name}"`).join(' ')
+    const signatureParams = `(${componentList});keyid="${keyId}";alg="rsa-v1_5-sha256";created=${created}`
+
+    signatureInput.push(['@signature-params', signatureParams])
+
+    const data = signatureInput.map(pair => `"${pair[0]}": ${pair[1]}`).join('\n')
+
+    const signer = crypto.createSign('sha256')
+    signer.update(data)
+    const signature = signer.sign(privateKey).toString('base64')
+    signer.end()
+
+    return {
+      'signature-input': `sig1=${signatureParams}`,
+      signature: `sig1=:${signature}:`
+    }
+  }
+
+  async validate (publicKeyPem, signatureInput, signature, method, url, headers) {
+    const inputs = this.#parseSignatureInput(signatureInput)
+    const input = this.#bestInput(inputs)
+    if (!input) {
+      throw new Error('No input with supported algorithms')
+    }
+    const bytes = this.#sigBytes(signature, input.name)
+    if (!bytes) {
+      throw new Error('No input with supported algorithms')
+    }
+    const data = this.#inputData(input, method, url, headers)
+    const verifier = this.#getVerifier(input.alg)
+    verifier.update(data)
+    const options = this.#getVerifierOptions(input.alg)
+    return verifier.verify(publicKeyPem, bytes, options)
+  }
+
+  #parseSignatureInput (signatureInput) {
+    const SIG_RE = /(\w+)=(\([^)]*\))((?:;[^,]*)*)/g
+    const PARAM_RE = /;(\w+)=("(?:[^"\\]|\\.)*"|\d+)/g
+    const signatures = {}
+    for (const match of signatureInput.matchAll(SIG_RE)) {
+      const name = match[1]
+      const attrStr = `${match[2]}${match[3]}`
+      const params = match[2].slice(1, -1)
+        .split(' ')
+        .filter(s => s.length > 0)
+        .map(token => {
+          const m = token.match(/^"([^"]+)"(.*)$/)
+          if (!m) return token
+          return m[2] ? `${m[1]}${m[2]}` : m[1]
+        })
+      const sigvals = {}
+      for (const paramMatch of match[3].matchAll(PARAM_RE)) {
+        const k = paramMatch[1]
+        const v = paramMatch[2]
+        sigvals[k] = v.match(/^\d+$/) ? parseInt(v) : v.slice(1, -1)
+      }
+      signatures[name] = { name, params, attrStr, ...sigvals }
+    }
+    return signatures
+  }
+
+  #bestInput (inputs) {
+    for (const alg of HTTPMessageSignature.#preferredAlgs) {
+      const entry = Object.values(inputs).find(sig => sig.alg === alg)
+      if (entry) {
+        return entry
+      }
+    }
+    return null
+  }
+
+  #inputData (input, method, url, headers) {
+    const signatureParams = []
+    const parsed = URL.parse(url)
+    for (const param of input.params) {
+      let value
+      switch (param) {
+        case '@method':
+          value = method.toUpperCase()
+          break
+        case '@authority':
+          value = headers.host
+          break
+        case '@path':
+          value = parsed.pathname
+          break
+        case '@query':
+          value = parsed.search
+          break
+        case '@target-uri':
+          value = url
+          break
+        case '@scheme':
+          value = parsed.protocol.slice(0, -1)
+          break
+        case '@request-target':
+          value = (parsed.search)
+            ? `${parsed.pathname}${parsed.search}`
+            : parsed.pathname
+          break
+        default:
+          if (param.startsWith('@query-param')) {
+            const nameMatch = param.match(/;name="([^"]+)"/)
+            if (!nameMatch) throw new Error('Missing name for @query-param')
+            const paramName = nameMatch[1]
+            signatureParams.push(['@query-param', parsed.searchParams.get(paramName), `name="${paramName}"`])
+            continue
+          }
+          if (param.length > 0 && param[0] === '@') {
+            throw new Error(`Unrecognized derived component ${param}`)
+          }
+          value = headers[param]
+      }
+      signatureParams.push([param, value])
+    }
+    signatureParams.push(['@signature-params', input.attrStr])
+    return signatureParams.map(
+      arr => arr.length === 3
+        ? `"${arr[0]}";${arr[2]}: ${arr[1]}`
+        : `"${arr[0]}": ${arr[1]}`
+    ).join('\n')
+  }
+
+  #getVerifier (alg) {
+    switch (alg) {
+      case 'ecdsa-p384-sha384':
+        return crypto.createVerify('sha384')
+      case 'ecdsa-p256-sha256':
+        return crypto.createVerify('sha256')
+      case 'rsa-pss-sha512':
+        return crypto.createVerify('sha512')
+      case 'rsa-pss-sha256':
+        return crypto.createVerify('sha256')
+      case 'rsa-v1_5-sha256':
+        return crypto.createVerify('sha256')
+    }
+  }
+
+  #getVerifierOptions (alg) {
+    switch (alg) {
+      case 'rsa-pss-sha512':
+      case 'rsa-pss-sha256':
+        return { padding: crypto.constants.RSA_PKCS1_PSS_PADDING }
+      default:
+        return { }
+    }
+  }
+
+  #sigBytes (sigHeader, name) {
+    const sigMatch = sigHeader.match(new RegExp(`${name}=:([^:]+):`))
+    if (!sigMatch) return false
+    return Buffer.from(sigMatch[1], 'base64')
+  }
+}

package/lib/httpsignatureauthenticator.js

@@ -1,27 +1,44 @@
+import assert from 'node:assert'
+
 import createHttpError from 'http-errors'
 
 import BotMaker from './botmaker.js'
 
 export class HTTPSignatureAuthenticator {
   static #maxDateDiff = 5 * 60 * 1000 // 5 minutes
-  #remoteKeyStorage = null
-  #logger = null
-  #digester = null
-  #signer = null
-  constructor (remoteKeyStorage, signer, digester, logger) {
+  #remoteKeyStorage
+  #logger
+  #digester
+  #signer
+  #messageSigner
+
+  constructor (remoteKeyStorage, signer, messageSigner, digester, logger) {
+    assert.ok(remoteKeyStorage)
+    assert.strictEqual(typeof remoteKeyStorage, 'object')
+    assert.ok(signer)
+    assert.strictEqual(typeof signer, 'object')
+    assert.ok(messageSigner)
+    assert.strictEqual(typeof messageSigner, 'object')
+    assert.ok(digester)
+    assert.strictEqual(typeof digester, 'object')
+    assert.ok(logger)
+    assert.strictEqual(typeof logger, 'object')
     this.#remoteKeyStorage = remoteKeyStorage
     this.#signer = signer
+    this.#messageSigner = messageSigner
     this.#digester = digester
     this.#logger = logger.child({ class: this.constructor.name })
   }
 
   async authenticate (req, res, next) {
+    const { formatter, origin, bots } = req.app.locals
+
     const signature = req.get('Signature')
     if (!signature) {
       // Just continue
       return next()
     }
-    const { formatter, origin, bots } = req.app.locals
+
     const originalUrl = req.originalUrl
     const fullUrl = `${origin}${originalUrl}`
     let parts
@@ -41,67 +58,133 @@ export class HTTPSignatureAuthenticator {
         return next()
       }
     }
+
+    const signatureInput = req.get('Signature-Input')
+
+    try {
+      if (signatureInput) {
+        await this.#authenticateMessageSignature(signature, signatureInput, originalUrl, req, res, next)
+      } else {
+        await this.#authenticateSignature(signature, originalUrl, req, res, next)
+      }
+    } catch (err) {
+      this.#logger.debug({ err }, 'Error authenticating key')
+      return next(err)
+    }
+  }
+
+  async #authenticateSignature (signature, originalUrl, req, res, next) {
     this.#logger.debug({ signature }, 'Got signed request')
     const date = req.get('Date')
     if (!date) {
-      return next(createHttpError(400, 'No date provided'))
+      throw createHttpError(400, 'No date provided')
     }
-    try {
-      if (Math.abs(Date.parse(date) - Date.now()) >
+    if (Math.abs(Date.parse(date) - Date.now()) >
         HTTPSignatureAuthenticator.#maxDateDiff) {
-        return next(createHttpError(400, 'Time skew too large'))
-      }
-    } catch (err) {
-      // for date parsing errors
-      return next(err)
+      throw createHttpError(400, 'Time skew too large')
     }
     if (req.rawBodyText && req.rawBodyText.length > 0) {
       const digest = req.get('Digest')
       if (!digest) {
-        return next(createHttpError(400, 'No digest provided'))
+        throw createHttpError(400, 'No digest provided')
       }
       const calculated = await this.#digester.digest(req.rawBodyText)
       if (!this.#digester.equals(digest, calculated)) {
         this.#logger.debug(`calculated: ${calculated} digest: ${digest}`)
-        return next(createHttpError(400, 'Digest mismatch'))
+        throw createHttpError(400, 'Digest mismatch')
       }
     }
     const { method, headers } = req
     this.#logger.debug({ originalUrl }, 'original URL')
-    try {
-      const keyId = this.#signer.keyId(signature)
-      this.#logger.debug({ keyId }, 'Signed with keyId')
-      const ok = await this.#remoteKeyStorage.getPublicKey(keyId)
-      if (!ok) {
-        throw createHttpError(400, 'public key not found')
+    const keyId = this.#signer.keyId(signature)
+    this.#logger.debug({ keyId }, 'Signed with keyId')
+    const ok = await this.#remoteKeyStorage.getPublicKey(keyId)
+    if (!ok) {
+      throw createHttpError(400, 'public key not found')
+    }
+    let owner = ok.owner
+    let publicKeyPem = ok.publicKeyPem
+    let result = await this.#signer.validate(publicKeyPem, signature, method, originalUrl, headers)
+    this.#logger.debug(`First validation result: ${result}`)
+    if (!result) {
+      // May be key rotation. Try again with uncached key
+      const ok2 = await this.#remoteKeyStorage.getPublicKey(keyId, false)
+      if (ok2.publicKeyPem === ok.publicKeyPem) {
+        this.#logger.debug('same keys')
+      } else {
+        this.#logger.debug('different keys')
+        owner = ok2.owner
+        publicKeyPem = ok2.publicKeyPem
+        result = await this.#signer.validate(publicKeyPem, signature, method, originalUrl, headers)
+        this.#logger.debug(`Validation result: ${result}`)
       }
-      let owner = ok.owner
-      let publicKeyPem = ok.publicKeyPem
-      let result = await this.#signer.validate(publicKeyPem, signature, method, originalUrl, headers)
-      this.#logger.debug(`First validation result: ${result}`)
-      if (!result) {
-        // May be key rotation. Try again with uncached key
-        const ok2 = await this.#remoteKeyStorage.getPublicKey(keyId, false)
-        if (ok2.publicKeyPem === ok.publicKeyPem) {
-          this.#logger.debug('same keys')
-        } else {
-          this.#logger.debug('different keys')
-          owner = ok2.owner
-          publicKeyPem = ok2.publicKeyPem
-          result = await this.#signer.validate(publicKeyPem, signature, method, originalUrl, headers)
-          this.#logger.debug(`Validation result: ${result}`)
-        }
+    }
+    if (result) {
+      this.#logger.debug(`Signature valid for ${keyId}`)
+      req.auth = req.auth || {}
+      req.auth.subject = owner
+      return next()
+    } else {
+      throw createHttpError(401, 'Unauthorized')
+    }
+  }
+
+  async #authenticateMessageSignature (signature, signatureInput, originalUrl, req, res, next) {
+    if (req.rawBodyText && req.rawBodyText.length > 0) {
+      const digest = req.get('Content-Digest')
+      if (!digest) {
+        throw createHttpError(400, 'No digest provided')
       }
-      if (result) {
-        this.#logger.debug(`Signature valid for ${keyId}`)
-        req.auth = req.auth || {}
-        req.auth.subject = owner
-        return next()
+      const calculated = await this.#digester.contentDigest(req.rawBodyText)
+      if (!this.#digester.equals(digest, calculated)) {
+        this.#logger.debug(`calculated: ${calculated} digest: ${digest}`)
+        throw createHttpError(400, 'Digest mismatch')
+      }
+    }
+    const created = this.#messageSigner.created(signatureInput)
+    if (!created) {
+      throw createHttpError(400, 'No created timestamp provided')
+    }
+    if (Math.abs(Date.now() - created * 1000) > HTTPSignatureAuthenticator.#maxDateDiff) {
+      throw createHttpError(400, 'Time skew too large')
+    }
+    const { method, headers } = req
+    const { origin } = req.app.locals
+    const url = `${origin}${originalUrl}`
+
+    const keyId = this.#messageSigner.keyId(signatureInput)
+    if (!keyId) {
+      throw createHttpError(400, 'no public key provided')
+    }
+    this.#logger.debug({ keyId }, 'Signed with keyId')
+    const ok = await this.#remoteKeyStorage.getPublicKey(keyId)
+    if (!ok) {
+      throw createHttpError(400, 'public key not found')
+    }
+    let owner = ok.owner
+    let publicKeyPem = ok.publicKeyPem
+    let result = await this.#messageSigner.validate(publicKeyPem, signatureInput, signature, method, url, headers)
+    this.#logger.debug(`First validation result: ${result}`)
+    if (!result) {
+      // May be key rotation. Try again with uncached key
+      const ok2 = await this.#remoteKeyStorage.getPublicKey(keyId, false)
+      if (ok2.publicKeyPem === ok.publicKeyPem) {
+        this.#logger.debug('same keys')
       } else {
-        return next(createHttpError(401, 'Unauthorized'))
+        this.#logger.debug('different keys')
+        owner = ok2.owner
+        publicKeyPem = ok2.publicKeyPem
+        result = await this.#messageSigner.validate(publicKeyPem, signatureInput, signature, method, url, headers)
+        this.#logger.debug(`Validation result: ${result}`)
       }
-    } catch (err) {
-      return next(err)
+    }
+    if (result) {
+      this.#logger.debug(`Signature valid for ${keyId}`)
+      req.auth = req.auth || {}
+      req.auth.subject = owner
+      return next()
+    } else {
+      throw createHttpError(401, 'Unauthorized')
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evanp/activitypub-bot",
-  "version": "0.36.2",
+  "version": "0.37.1",
   "description": "server-side ActivityPub bot framework",
   "type": "module",
   "main": "lib/index.js",
@@ -43,7 +43,7 @@
     "sequelize": "^6.37.7"
   },
   "devDependencies": {
-    "@evanp/activitypub-nock": "^0.7.0",
+    "@evanp/activitypub-nock": "^0.9.2",
     "eslint": "^8.57.1",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.29.1",