Firma HMAC

import express from 'express';
import crypto from 'node:crypto';

const app = express();

const TOLERANCE_SECONDS = 300;
const SECRETS = [
  process.env.BP_WEBHOOK_SECRET,
  process.env.BP_WEBHOOK_SECRET_NEXT,
].filter(Boolean);

if (SECRETS.length === 0) {
  throw new Error('Nessun segreto webhook configurato');
}

function parseSignatureHeader(header) {
  const result = { timestamp: null, signatures: [] };
  for (const segment of header.split(',')) {
    const separatorIndex = segment.indexOf('=');
    if (separatorIndex === -1) continue;
    const key = segment.slice(0, separatorIndex).trim();
    const value = segment.slice(separatorIndex + 1).trim();
    if (key === 't') result.timestamp = Number(value);
    if (key === 'v1') result.signatures.push(value);
  }
  return result;
}

function timingSafeEqualHex(a, b) {
  const bufferA = Buffer.from(a, 'utf8');
  const bufferB = Buffer.from(b, 'utf8');
  if (bufferA.length !== bufferB.length) return false;
  return crypto.timingSafeEqual(bufferA, bufferB);
}

export function verifySignature(rawBody, signatureHeader, nowSeconds) {
  if (!signatureHeader) {
    return { valid: false, reason: 'header-mancante' };
  }

  const { timestamp, signatures } = parseSignatureHeader(signatureHeader);

  if (!Number.isFinite(timestamp)) {
    return { valid: false, reason: 'timestamp-non-valido' };
  }
  if (Math.abs(nowSeconds - timestamp) > TOLERANCE_SECONDS) {
    return { valid: false, reason: 'timestamp-fuori-tolleranza' };
  }
  if (signatures.length === 0) {
    return { valid: false, reason: 'firma-assente' };
  }

  const signedPayload = `${timestamp}.${rawBody}`;

  for (const secret of SECRETS) {
    const expected = crypto
      .createHmac('sha256', secret)
      .update(signedPayload, 'utf8')
      .digest('hex');

    for (const candidate of signatures) {
      if (timingSafeEqualHex(candidate, expected)) {
        return { valid: true, reason: 'ok' };
      }
    }
  }

  return { valid: false, reason: 'firma-non-corrispondente' };
}

app.post(
  '/webhooks/blupantheon',
  express.raw({ type: 'application/json', limit: '2mb' }),
  async (req, res) => {
    const rawBody = req.body.toString('utf8');
    const now = Math.floor(Date.now() / 1000);
    const result = verifySignature(rawBody, req.get('X-BP-Signature'), now);

    if (!result.valid) {
      console.warn('Webhook rifiutato:', result.reason);
      const status = result.reason === 'timestamp-fuori-tolleranza' ? 400 : 401;
      return res.status(status).json({ error: result.reason });
    }

    const deliveryId = req.get('X-BP-Delivery');
    const event = JSON.parse(rawBody);

    if (await alreadyProcessed(deliveryId)) {
      return res.status(202).json({ status: 'duplicato-ignorato' });
    }
    await markReceived(deliveryId, event.id);

    setImmediate(() => {
      processEvent(event).catch((error) =>
        console.error('Elaborazione fallita', event.id, error),
      );
    });

    return res.status(202).json({ status: 'accettato' });
  },
);

// Il parser JSON generico va registrato DOPO la rotta raw.
app.use(express.json());

const processedDeliveries = new Set();
async function alreadyProcessed(deliveryId) {
  return processedDeliveries.has(deliveryId);
}
async function markReceived(deliveryId) {
  processedDeliveries.add(deliveryId);
}
async function processEvent(event) {
  console.log('Evento elaborato:', event.event, event.id);
}

app.listen(3000, () => console.log('In ascolto sulla porta 3000'));