Webhooks

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

const app = express();

// `express.raw` est indispensable : il faut les octets reçus, pas l'objet parsé.
app.post(
  '/hooks/djonanko',
  express.raw({ type: 'application/json' }),
  (req, res) => {
    if (!verifier(req.body, req.get('Djonanko-Signature'), process.env.DJONANKO_WEBHOOK_SECRET)) {
      return res.status(401).send('signature invalide');
    }

    const evenement = JSON.parse(req.body.toString('utf8'));

    // On accuse réception tout de suite : le traitement ne doit pas faire
    // dépasser les 15 secondes.
    res.status(200).send('ok');

    traiterEnTacheDeFond(evenement).catch(console.error);
  },
);

function verifier(rawBody, header, secret, toleranceSeconds = 300) {
  if (!header) return false;

  const parts = Object.fromEntries(
    header.split(',').map((p) => p.trim().split('=')),
  );

  const age = Math.abs(Date.now() / 1000 - Number(parts.t));
  if (!Number.isFinite(age) || age > toleranceSeconds) return false;

  const attendu = crypto
    .createHmac('sha256', secret)
    .update(`${parts.t}.${rawBody.toString('utf8')}`)
    .digest('hex');

  const a = Buffer.from(attendu);
  const b = Buffer.from(parts.v1 ?? '');

  // Comparaison à temps constant : une comparaison naïve laisse fuir l'octet
  // où elle s'arrête, ce qui suffit à reconstituer une signature valide.
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

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

app = Flask(__name__)

@app.post('/hooks/djonanko')
def hook():
    # request.get_data() renvoie les octets reçus, avant tout parsing.
    raw = request.get_data()

    if not verifier(raw, request.headers.get('Djonanko-Signature'), SECRET):
        return 'signature invalide', 401

    evenement = request.get_json()
    traiter_en_tache_de_fond(evenement)
    return 'ok', 200


def verifier(raw_body: bytes, header: str, secret: str, tolerance: int = 300) -> bool:
    if not header:
        return False
    try:
        parts = dict(p.strip().split('=', 1) for p in header.split(','))
        age = abs(time.time() - int(parts['t']))
    except (KeyError, ValueError):
        return False

    if age > tolerance:
        return False

    attendu = hmac.new(
        secret.encode(),
        f"{parts['t']}.".encode() + raw_body,
        hashlib.sha256,
    ).hexdigest()

    return hmac.compare_digest(attendu, parts.get('v1', ''))

<?php
// php://input donne le corps brut, avant tout décodage.
$raw = file_get_contents('php://input');
$header = $_SERVER['HTTP_DJONANKO_SIGNATURE'] ?? '';

if (!verifier($raw, $header, getenv('DJONANKO_WEBHOOK_SECRET'))) {
    http_response_code(401);
    exit('signature invalide');
}

$evenement = json_decode($raw, true);
http_response_code(200);
echo 'ok';

function verifier(string $rawBody, string $header, string $secret, int $tolerance = 300): bool
{
    $parts = [];
    foreach (explode(',', $header) as $segment) {
        $pair = explode('=', trim($segment), 2);
        if (count($pair) === 2) {
            $parts[$pair[0]] = $pair[1];
        }
    }

    if (!isset($parts['t'], $parts['v1'])) {
        return false;
    }
    if (abs(time() - (int) $parts['t']) > $tolerance) {
        return false;
    }

    $attendu = hash_hmac('sha256', $parts['t'] . '.' . $rawBody, $secret);

    return hash_equals($attendu, $parts['v1']);
}