Brute Force Attack in Sails with Hmac Signatures

A brute force attack against an API using Hmac Signatures in a Sails application can occur when the service does not adequately protect the signing secret or when signature validation logic is weak. In this setup, each request is typically signed with an HMAC (Hash-based Message Authentication Code), often using HmacSha256, where the signature is computed over selected parts of the request (method, path, timestamp, and payload) using a shared secret known to the client and server.

If an endpoint accepts high numbers of authentication attempts without throttling or progressive delays, an attacker can systematically guess secrets or nonces and observe whether the server returns distinct error messages for valid versus invalid signatures. In Sails, if controller actions do not enforce uniform response behavior and do not apply constant-time comparisons, timing differences can leak information about the signature validity. This can allow an attacker to iteratively refine guesses, especially when requests include timestamps or nonces that are not tightly bounded.

Additionally, if the Sails API does not enforce per-client rate limits or lacks protections such as one-time nonces and replay prevention, an attacker may replay captured requests while slightly altering parameters to probe for secret derivation patterns. Without proper safeguards such as request deduplication, the API surface remains vulnerable to credential or secret brute force via repeated Hmac-based attempts.

Consider an endpoint that verifies Hmac signatures without strict timestamp windows or request deduplication:

// api/controllers/UserController.js
const crypto = require('crypto');

function verifyHmac(req, res) {
  const { timestamp, signature, data } = req.allParams();
  const windowMs = 300000; // 5 minutes
  const now = Date.now();

  if (Math.abs(now - parseInt(timestamp, 10)) > windowMs) {
    return res.badRequest('Timestamp expired');
  }

  const secret = sails.config.hmacSecret;
  const computed = crypto.createHmac('sha256', secret)
                         .update(timestamp + JSON.stringify(data))
                         .digest('hex');

  if (computed !== signature) {
    return res.unauthorized('Invalid signature');
  }

  return res.ok('Request accepted');
}

In this example, if the server returns different messages for expired timestamps versus invalid signatures, and if there is no rate limiting, an attacker can distinguish between these cases and mount a brute force or timing-based attack. The lack of request deduplication also means replay attempts are not automatically detected.

Furthermore, if the Hmac secret is derived from a low-entropy source or is transmitted or logged inadvertently, the attack surface grows. Sails applications must ensure secrets are managed securely and that validation logic treats all failures identically, applies a consistent timing window, and rejects replayed requests.

To mitigate brute force risks when using Hmac Signatures in Sails, implement strict request validation, constant-time comparison, replay protection, and rate limiting. The following practices and code examples help harden the implementation.

1. Use constant-time comparison to prevent timing attacks:

// api/utils/hmacUtils.js
const crypto = require('crypto');

function safeCompare(a, b) {
  if (a.length !== b.length) {
    return false;
  }
  let result = 0;
  for (let i = 0; i < a.length; i++) {
    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
  }
  return result === 0;
}

module.exports = { safeCompare };

2. Enforce a tight timestamp window and include a replay cache to prevent reuse:

// api/controllers/UserController.js
const crypto = require('crypto');
const { safeCompare } = require('../utils/hmacUtils');

const REPLAY_CACHE_TTL = 300; // seconds
const replayCache = new Set();

module.exports = {
  friendlyName: 'Verify Hmac Request',

  fn: async function (req, res) {
    const { timestamp, signature, data, requestId } = req.allParams();
    const windowMs = 60000; // 1 minute
    const now = Date.now();

    if (Math.abs(now - parseInt(timestamp, 10)) > windowMs) {
      return res.badRequest('Request expired');
    }

    if (!requestId || replayCache.has(requestId)) {
      return res.badRequest('Duplicate request');
    }

    const secret = sails.config.hmacSecret;
    const computed = crypto.createHmac('sha256', secret)
                           .update(timestamp + JSON.stringify(data) + (requestId || ''))
                           .digest('hex');

    if (!safeCompare(computed, signature)) {
      return res.unauthorized('Invalid request');
    }

    replayCache.add(requestId);
    setTimeout(() => replayCache.delete(requestId), REPLAY_CACHE_TTL * 1000);

    return res.ok('Request verified');
  }
};

3. Apply rate limiting at the controller or gateway level to restrict attempts per client identifier:

// config/policies.js
module.exports.policies = {
  '*': ['rateLimiter']
};

// api/policies/rateLimiter.js
const rateLimits = new Map();

module.exports = function rateLimiter(req, res, next) {
  const clientId = req.headers['x-client-id'] || req.ip;
  const now = Date.now();
  const windowSec = 60;
  const maxRequests = 30;

  if (!rateLimits.has(clientId)) {
    rateLimits.set(clientId, []);
  }
  let timestamps = rateLimits.get(clientId).filter(t => now - t < windowSec * 1000);
  if (timestamps.length >= maxRequests) {
    return res.status(429).send('Too many requests');
  }
  timestamps.push(now);
  rateLimits.set(clientId, timestamps);
  return next();
};

4. Ensure the Hmac secret is stored securely and rotated periodically, and avoid logging signatures or secrets.