Arp Spoofing in Restify with Hmac Signatures

Arp Spoofing is a Layer 2 network attack where an adversary sends falsified ARP messages to associate their MAC address with the IP of a legitimate host, such as a REST API server running Restify. In a typical Restify service that relies on Hmac Signatures for request authentication, the server validates the signature to ensure request integrity and origin authenticity. If an attacker successfully positions themselves on the local network via Arp Spoofing, they can intercept or redirect traffic between a client and the Restify server.

This interception enables the attacker to observe and manipulate in-flight requests. Because Hmac Signatures often rely on a shared secret and a deterministic algorithm (e.g., HMAC-SHA256) over selected headers and body, the attacker who can capture and replay those requests might succeed if nonces or timestamps are absent or improperly validated. For example, if the Restify service accepts requests with the same HTTP method, path, headers, and body, the intercepted Hmac-signed request can be forwarded to the server, and the signature will verify correctly. The server cannot inherently distinguish a legitimate replay from a genuine request because the signature remains valid for that exact request context.

The risk is compounded when the Restify service uses Hmac Signatures without additional transport protections or replay countermeasures. ARP-level tampering does not require breaking the cryptographic primitive; it exploits operational gaps in how the service sequences verification and trust. An attacker can modify parameters within the allowed set, such as changing a user ID in the payload or headers, provided the Hmac is recalculated with the shared secret—which is feasible if the attacker has compromised a client or performed a man-in-the-middle step facilitated by the spoofed ARP entries. This illustrates why Hmac Signatures must be bound to a session or contextual element and why network-layer attacks like Arp Spoofing elevate the impact of otherwise sound message-level authentication.

To mitigate Arp Spoofing risks in a Restify service that uses Hmac Signatures, implement robust replay prevention and contextual binding in your authentication logic. The following examples demonstrate a hardened approach using Node.js and the Restify framework.

Example 1: Hmac Signature with nonce and timestamp

This approach adds a one-time nonce and a timestamp window to ensure each request is unique and time-bound, rendering replayed Arp-spoofed requests invalid.

const crypto = require('crypto');
const restify = require('restify');

function verifyHmac(req, res, next) {
  const sharedSecret = process.env.HMAC_SHARED_SECRET; // store securely
  const { timestamp, nonce, signature } = req.headers;
  const method = req.method;
  const path = req.path;
  const body = req.body ? JSON.stringify(req.body) : '';

  // Basic sanity checks
  if (!timestamp || !nonce || !signature) {
    return res.send(401, { error: 'Missing authentication headers' });
  }

  // Replay window: allow 5 minutes skew
  const now = Date.now();
  const tolerance = 5 * 60 * 1000;
  if (Math.abs(now - parseInt(timestamp, 10)) > tolerance) {
    return res.send(401, { error: 'Request expired' });
  }

  // Ensure nonce has not been used before (store in a short-lived cache)
  if (isNonceSeen(nonce, timestamp)) {
    return res.send(401, { error: 'Replay detected' });
  }
  markNonceSeen(nonce, timestamp);

  const stringToSign = `${method}\n${path}\n${timestamp}\n${nonce}\n${body}`;
  const expected = crypto.createHmac('sha256', sharedSecret)
                         .update(stringToSign)
                         .digest('hex');

  if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    return res.send(401, { error: 'Invalid signature' });
  }
  return next();
}

// Minimal nonce cache (use Redis or similar in production)
const seenNonces = new Map();
function isNonceSeen(nonce, timestamp) {
  const key = `${nonce}:${timestamp}`;
  if (seenNonces.has(key)) return true;
  seenNonces.set(key, true);
  // Cleanup older entries periodically
  return false;
}
function markNonceSeen(nonce, timestamp) {
  const key = `${nonce}:${timestamp}`;
  seenNonces.set(key, true);
}

const server = restify.createServer();
server.use(restify.plugins.bodyParser());
server.use((req, res, next) => {
  // Apply verification to relevant routes
  if (req.method === 'POST' || req.method === 'PUT') {
    return verifyHmac(req, res, next);
  }
  return next();
});

server.post('/api/resource', (req, res, next) => {
  res.send(200, { ok: true });
  return next();
});

server.listen(8080, () => console.log('Listening'));

Example 2: Include a per-client identifier and enforce transport integrity

Binding the Hmac to a client identifier and enforcing HTTPS/TLS reduces the window for successful interception and misuse, even if Arp Spoofing occurs on the network.

function verifyHmacWithClient(req, res, next) {
  const sharedSecret = process.env.HMAC_SHARED_SECRET;
  const { timestamp, nonce, signature, clientId } = req.headers;
  const method = req.method;
  const path = req.path;
  const body = req.body ? JSON.stringify(req.body) : '';

  if (!clientId) {
    return res.send(401, { error: 'Missing client identifier' });
  }

  // Replay and time window checks
  const now = Date.now();
  const tolerance = 5 * 60 * 1000;
  if (!timestamp || Math.abs(now - parseInt(timestamp, 10)) > tolerance) {
    return res.send(401, { error: 'Invalid timestamp' });
  }

  if (!nonce) {
    return res.send(401, { error: 'Missing nonce' });
  }
  if (isNonceSeen(nonce, timestamp)) {
    return res.send(401, { error: 'Nonce already used' });
  }
  markNonceSeen(nonce, timestamp);

  const stringToSign = `${clientId}\n${method}\n${path}\n${timestamp}\n${nonce}\n${body}`;
  const expected = crypto.createHmac('sha256', sharedSecret)
                         .update(stringToSign)
                         .digest('hex');

  if (!signature || !crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    return res.send(401, { error: 'Bad signature' });
  }

  // Enforce that requests originate over TLS in production
  if (!req.secure) {
    return res.send(403, { error: 'Transport must be secure' });
  }

  return next();
}

By incorporating a nonce, timestamp, client identifier, and requiring secure transport, you reduce the effectiveness of Arp Spoofing combined with request replay. Even if an attacker intercepts a valid Hmac-signed request, the nonce prevents reuse, and the time window limits exposure. These patterns align with best practices for message-level integrity when network-layer threats are a concern.