Buffer Overflow in Express with Hmac Signatures

Buffer overflow conditions arise when an application copies more data into a fixed-size buffer than it can hold. In Express, this typically occurs while processing raw request bodies, query strings, or headers before signature verification. When Hmac Signatures are used—commonly via the express-http-signature or similar middleware—the server first reads the raw payload to compute and verify the signature. If the body is read into a fixed-size buffer or processed with unsafe string concatenation before validation, an oversized payload can overflow the buffer, leading to memory corruption or arbitrary code execution.

Specifically, if the Express app uses a streaming approach that accumulates data into a limited buffer (for example, using a manually managed Buffer.concat with an implicit upper bound or reading the stream into a fixed-size Buffer.alloc), an attacker can send a request with a body larger than expected. Even if the Hmac signature is verified afterward, the overflow may occur during the read phase, before the signature check completes. This means the integrity protection of Hmac Signatures does not prevent the overflow if the body is processed unsafely prior to verification.

Real-world examples include using req.on('data', ...) to accumulate chunks into a pre-allocated buffer without dynamic resizing, or using raw-body or body-parser with size limits that are too high or not enforced before signature validation. Vulnerable patterns also appear when developers concatenate raw chunks into a JavaScript string to compute the signature, because strings in JavaScript are UTF-16 and can exacerbate memory misuse when handling binary data. Such combinations expose the attack surface even when Hmac Signatures are employed for integrity, because the overflow occurs earlier in the request lifecycle.

Common indicators of a vulnerable setup include missing body size constraints, use of unbounded accumulation, and lack of streaming backpressure handling. Attack patterns mirror classic buffer overflow exploits—stack smashing or out-of-bounds read—often leading to denial of service or code execution. This aligns with findings from scans run by tools such as middleBrick, which identify unsafe consumption and input validation issues in conjunction with signature verification logic.

Remediation focuses on ensuring that the request body is either limited before signature verification or that the signature verification operates on a stream without unsafe buffering. Use a size-limited body parser or enforce a maximum content length before reading the raw bytes for the Hmac signature. Below are concrete, safe patterns for Express.

Safe streaming with size limit before verification

const express = require('express');
const crypto = require('crypto');
const app = express();
const MAX_BODY_SIZE = 1024 * 1024; // 1 MB

app.use(express.raw({ type: '*/*', limit: MAX_BODY_SIZE }));

app.post('/webhook', (req, res) => {
  const provided = req.get('X-Signature');
  const secret = process.env.WEBHOOK_SECRET;
  const hmac = crypto.createHmac('sha256', secret);
  const digest = 'sha256=' + hmac.update(req.body).digest('hex');

  if (!crypto.timingSafeEqual(Buffer.from(provided), Buffer.from(digest))) {
    return res.status(401).send('Invalid signature');
  }

  // Process verified payload safely
  res.status(200).send('OK');
});

Using a streaming verifier to avoid large buffers

const express = require('express');
const crypto = require('crypto');
const { PassThrough } = require('stream');
const app = express();
const MAX_BODY_SIZE = 1024 * 1024;

app.post('/webhook', (req, res, next) => {
  let received = 0;
  const limitedStream = new PassThrough();
  req
    .on('data', (chunk) => {
      received += chunk.length;
      if (received > MAX_BODY_SIZE) {
        return res.status(413).send('Payload too large');
      }
      limitedStream.write(chunk);
    })
    .on('end', () => {
      limitedStream.push(null);
      const chunks = [];
      limitedStream.on('data', (c) => chunks.push(c));
      limitedStream.on('end', () => {
        const body = Buffer.concat(chunks);
        const provided = req.get('X-Signature');
        const secret = process.env.WEBHOOK_SECRET;
        const hmac = crypto.createHmac('sha256', secret);
        const digest = 'sha256=' + hmac.update(body).digest('hex');
        if (!crypto.timingSafeEqual(Buffer.from(provided), Buffer.from(digest))) {
          return res.status(401).send('Invalid signature');
        }
        res.status(200).send('OK');
      });
    });
});

Key practices

• Always enforce a strict limit on raw body size before signature computation.
• Use crypto.timingSafeEqual to compare Hmac digests to prevent timing attacks.
• Avoid accumulating data into JavaScript strings for binary payloads; prefer Buffer.
• Validate the presence of the signature header early and reject malformed requests without processing the body further.

These approaches ensure that Hmac Signatures provide integrity without inadvertently creating a buffer overflow surface. They align with secure coding guidance and help satisfy checks related to input validation and unsafe consumption that middleBrick reports on.