Segurança e verificação

const crypto = require('crypto');
const express = require('express');
const app = express();

const TOLERANCIA_SEGUNDOS = 300; // 5 minutos

// express.raw() entrega o corpo como Buffer, sem parsear
app.post('/webhooks/socialsell', express.raw({ type: 'application/json' }), (req, res) => {
  const assinatura = req.headers['x-webhook-signature'];
  const timestamp = req.headers['x-webhook-timestamp'];
  const secret = process.env.SOCIALSELL_WEBHOOK_SECRET;

  if (!assinaturaValida(req.body, timestamp, assinatura, secret)) {
    return res.status(401).json({ error: 'Assinatura inválida' });
  }

  const evento = JSON.parse(req.body);
  console.log('Evento recebido:', evento.type);

  // Responda rápido e processe depois
  res.status(200).send('OK');
});

function assinaturaValida(corpoBruto, timestamp, assinatura, secret) {
  if (!assinatura || !timestamp) return false;

  // Rejeita entregas fora da janela — protege contra replay
  const idade = Math.abs(Math.floor(Date.now() / 1000) - Number(timestamp));
  if (!Number.isFinite(idade) || idade > TOLERANCIA_SEGUNDOS) return false;

  const esperada = 'sha256=' + crypto
    .createHmac('sha256', secret)
    .update(`${timestamp}.${corpoBruto}`)
    .digest('hex');

  const a = Buffer.from(assinatura);
  const b = Buffer.from(esperada);
  // Comparação em tempo constante: `===` vaza, pelo tempo de resposta,
  // quanto do prefixo estava certo
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

import hmac
import hashlib
import os
import time
from flask import Flask, request, abort

app = Flask(__name__)
TOLERANCIA_SEGUNDOS = 300

@app.route('/webhooks/socialsell', methods=['POST'])
def webhook():
    assinatura = request.headers.get('X-Webhook-Signature', '')
    timestamp = request.headers.get('X-Webhook-Timestamp', '')
    secret = os.environ['SOCIALSELL_WEBHOOK_SECRET'].encode()

    if not assinatura_valida(request.data, timestamp, assinatura, secret):
        abort(401)

    evento = request.json
    print(f"Evento recebido: {evento['type']}")
    return 'OK', 200


def assinatura_valida(corpo_bruto, timestamp, assinatura, secret):
    if not assinatura or not timestamp:
        return False

    try:
        idade = abs(int(time.time()) - int(timestamp))
    except ValueError:
        return False
    if idade > TOLERANCIA_SEGUNDOS:
        return False

    base = f"{timestamp}.".encode() + corpo_bruto
    esperada = 'sha256=' + hmac.new(secret, base, hashlib.sha256).hexdigest()
    return hmac.compare_digest(assinatura, esperada)

<?php
$tolerancia = 300;

$corpoBruto = file_get_contents('php://input');
$assinatura = $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '';
$timestamp  = $_SERVER['HTTP_X_WEBHOOK_TIMESTAMP'] ?? '';
$secret     = getenv('SOCIALSELL_WEBHOOK_SECRET');

if ($assinatura === '' || $timestamp === '' || abs(time() - (int) $timestamp) > $tolerancia) {
    http_response_code(401);
    exit('Assinatura inválida');
}

$esperada = 'sha256=' . hash_hmac('sha256', $timestamp . '.' . $corpoBruto, $secret);

if (!hash_equals($esperada, $assinatura)) {
    http_response_code(401);
    exit('Assinatura inválida');
}

$evento = json_decode($corpoBruto, true);
error_log('Evento recebido: ' . $evento['type']);

http_response_code(200);
echo 'OK';

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"net/http"
	"os"
	"strconv"
	"time"
)

const toleranciaSegundos = 300

func handler(w http.ResponseWriter, r *http.Request) {
	corpoBruto, _ := io.ReadAll(r.Body)
	assinatura := r.Header.Get("X-Webhook-Signature")
	timestamp := r.Header.Get("X-Webhook-Timestamp")
	secret := os.Getenv("SOCIALSELL_WEBHOOK_SECRET")

	ts, err := strconv.ParseInt(timestamp, 10, 64)
	if err != nil || abs(time.Now().Unix()-ts) > toleranciaSegundos {
		http.Error(w, "Assinatura inválida", http.StatusUnauthorized)
		return
	}

	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(timestamp + "."))
	mac.Write(corpoBruto)
	esperada := "sha256=" + hex.EncodeToString(mac.Sum(nil))

	if !hmac.Equal([]byte(esperada), []byte(assinatura)) {
		http.Error(w, "Assinatura inválida", http.StatusUnauthorized)
		return
	}

	var evento struct {
		Type string `json:"type"`
	}
	json.Unmarshal(corpoBruto, &evento)

	w.WriteHeader(http.StatusOK)
	w.Write([]byte("OK"))
}

func abs(n int64) int64 {
	if n < 0 {
		return -n
	}
	return n
}