Webhook Signature Verification

// Provider: signing webhook payloads
const crypto = require('crypto');

function signWebhook(payload, secret) {
  // Normalize payload as string
  const payloadStr = typeof payload === 'string'
    ? payload
    : JSON.stringify(payload);

  // Create HMAC-SHA256 signature
  const signature = crypto
    .createHmac('sha256', secret)
    .update(payloadStr, 'utf8')
    .digest('hex');

  return signature;
}

async function sendSignedWebhook(url, payload, secret) {
  const payloadStr = JSON.stringify(payload);
  const timestamp = Math.floor(Date.now() / 1000);
  
  // Include timestamp in signature to prevent replay attacks
  const signedPayload = `${timestamp}.${payloadStr}`;
  const signature = signWebhook(signedPayload, secret);

  try {
    const response = await axios.post(url, payload, {
      headers: {
        'Content-Type': 'application/json',
        'X-Webhook-Signature': 
          `t=${timestamp},v1=${signature}`,
        'X-Webhook-ID': payload.id,
      },
    });
    return response.status;
  } catch (error) {
    throw new Error(`Webhook delivery failed: ${error.message}`);
  }
}

// Usage
const webhookSecret = process.env.WEBHOOK_SECRET;
const payload = {
  id: 'evt_001',
  type: 'order.created',
  data: { orderId: 'ord_123' },
};

sendSignedWebhook(
  'https://consumer.example.com/webhook',
  payload,
  webhookSecret
);

// Consumer: verifying webhook signatures
const crypto = require('crypto');

app.post('/webhook', (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  const webhookId = req.headers['x-webhook-id'];

  if (!signature) {
    return res.status(401).json({ error: 'Missing signature' });
  }

  // Parse signature header
  const parts = signature.split(',');
  const timestamp = parts.find(p => p.startsWith('t='))?.slice(2);
  const signatureValue = parts.find(p => p.startsWith('v1='))?.slice(3);

  if (!timestamp || !signatureValue) {
    return res.status(401).json({ error: 'Invalid signature format' });
  }

  // Prevent replay attacks (allow 5 minute tolerance)
  const now = Math.floor(Date.now() / 1000);
  if (now - parseInt(timestamp) > 300) {
    return res.status(401).json({ error: 'Signature expired' });
  }

  // Look up secret for this webhook
  const secret = getWebhookSecret(webhookId);

  // Verify signature
  const payload = JSON.stringify(req.body);
  const signedContent = `${timestamp}.${payload}`;
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(signedContent, 'utf8')
    .digest('hex');

  // Timing-safe comparison
  if (!crypto.timingSafeEqual(
    Buffer.from(signatureValue),
    Buffer.from(expectedSignature)
  )) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  // Signature verified, process webhook
  processWebhook(req.body);
  res.status(200).json({ status: 'ok' });
});

function getWebhookSecret(webhookId) {
  // Retrieve secret from database
  return database.getWebhookSecret(webhookId);
}

// Provider supporting multiple signature schemes
const crypto = require('crypto');

function signPayload(payload, options) {
  const { algorithm, secret, privateKey, keyId } = options;
  const payloadStr = JSON.stringify(payload);
  const timestamp = Math.floor(Date.now() / 1000);
  const signedContent = `${timestamp}.${payloadStr}`;

  let signature;
  switch (algorithm) {
    case 'hmac-sha256':
      signature = crypto
        .createHmac('sha256', secret)
        .update(signedContent)
        .digest('base64');
      break;

    case 'rsa-sha256':
      signature = crypto
        .sign('sha256', Buffer.from(signedContent), privateKey)
        .toString('base64');
      break;

    case 'hmac-sha512':
      signature = crypto
        .createHmac('sha512', secret)
        .update(signedContent)
        .digest('base64');
      break;
  }

  return {
    signature,
    algorithm,
    timestamp,
    keyId,
  };
}

// Headers for different schemes
const hmacHeaders = {
  'X-Signature-256': `t=${timestamp},hmac=${signature}`,
};

const rsaHeaders = {
  'X-Signature-RSA': `t=${timestamp},rsa=${signature},keyid=${keyId}`,
  'X-Signature-Algorithm': 'rsa-sha256',
};

// Consumer verification for RSA
function verifyRSASignature(payload, signature, timestamp, publicKey) {
  const signedContent = `${timestamp}.${JSON.stringify(payload)}`;
  return crypto.verify(
    'sha256',
    Buffer.from(signedContent),
    publicKey,
    Buffer.from(signature, 'base64')
  );
}