Recevoir et vérifier les rappels

à la réception d'un rappel
  corps ← les octets reçus, avant tout décodage JSON
  si sha-256(corps) ≠ Content-Digest → refuser
  params ← Signature-Input, après « umeme= »
  si created date de plus de 5 minutes → refuser
  base ← "@method", "@target-uri", "content-digest", "@signature-params"
  clé ← GET /v1/cle-publique, par keyid
  si ECDSA P-256 (base, Signature, clé) est fausse → refuser
  sinon → le rappel vient d'Umeme

import { createHash, createPublicKey, verify } from "node:crypto";

// cles : la réponse de GET /v1/cle-publique, gardée en cache.
export function verifierRappel(entetes, corpsBrut, urlDeRappel, cles) {
  // Étape 2 : le corps n'a pas changé en route.
  const condensat = createHash("sha256").update(corpsBrut).digest("base64");
  if (entetes["content-digest"] !== `sha-256=:${condensat}:`) {
    return false;
  }

  // Étape 3 : ce que la signature couvre, quand, avec quelle clé.
  const entree = entetes["signature-input"];
  const params = entree.slice(entree.indexOf("=") + 1);
  const keyid = /keyid="([^"]+)"/.exec(params)[1];
  const created = Number(/created=(\d+)/.exec(params)[1]);
  if (Math.abs(Date.now() / 1000 - created) > 300) {
    return false;
  }

  // Étape 4 : la base de signature.
  const base = [
    '"@method": POST',
    `"@target-uri": ${urlDeRappel}`,
    `"content-digest": ${entetes["content-digest"]}`,
    `"@signature-params": ${params}`,
  ].join("\n");

  // Étape 5 : la clé du keyid. Inconnue : rechargez GET /v1/cle-publique.
  const cle = cles.find((c) => c.keyid === keyid);
  if (!cle) {
    return false;
  }

  // Étape 6 : ECDSA P-256 sur la signature brute (r puis s).
  const signature = Buffer.from(/:(.+):/.exec(entetes["signature"])[1], "base64");
  return verify(
    "sha256",
    Buffer.from(base),
    { key: createPublicKey(cle.cle), dsaEncoding: "ieee-p1363" },
    signature,
  );
}

import base64
import hashlib
import re
import time

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric.utils import encode_dss_signature


# cles : la réponse de GET /v1/cle-publique, gardée en cache.
def verifier_rappel(entetes, corps_brut, url_de_rappel, cles):
    # Étape 2 : le corps n'a pas changé en route.
    condensat = base64.b64encode(hashlib.sha256(corps_brut).digest()).decode()
    if entetes["Content-Digest"] != f"sha-256=:{condensat}:":
        return False

    # Étape 3 : ce que la signature couvre, quand, avec quelle clé.
    params = entetes["Signature-Input"].split("=", 1)[1]
    keyid = re.search(r'keyid="([^"]+)"', params).group(1)
    created = int(re.search(r"created=(\d+)", params).group(1))
    if abs(time.time() - created) > 300:
        return False

    # Étape 4 : la base de signature.
    base = "\n".join([
        '"@method": POST',
        f'"@target-uri": {url_de_rappel}',
        f'"content-digest": {entetes["Content-Digest"]}',
        f'"@signature-params": {params}',
    ])

    # Étape 5 : la clé du keyid. Inconnue : rechargez GET /v1/cle-publique.
    cle = next((c for c in cles if c["keyid"] == keyid), None)
    if cle is None:
        return False

    # Étape 6 : la bibliothèque attend du DER ; la RFC donne r puis s.
    brute = base64.b64decode(re.search(r":(.+):", entetes["Signature"]).group(1))
    r = int.from_bytes(brute[:32], "big")
    s = int.from_bytes(brute[32:], "big")
    publique = serialization.load_pem_public_key(cle["cle"].encode())
    try:
        publique.verify(encode_dss_signature(r, s), base.encode(), ec.ECDSA(hashes.SHA256()))
    except Exception:
        return False
    return True

<?php

// $cles : la réponse de GET /v1/cle-publique, gardée en cache.
function verifierRappel(array $entetes, string $corpsBrut, string $urlDeRappel, array $cles): bool
{
    // Étape 2 : le corps n'a pas changé en route.
    $condensat = base64_encode(hash('sha256', $corpsBrut, true));
    if ($entetes['content-digest'] !== "sha-256=:$condensat:") {
        return false;
    }

    // Étape 3 : ce que la signature couvre, quand, avec quelle clé.
    $entree = $entetes['signature-input'];
    $params = substr($entree, strpos($entree, '=') + 1);
    preg_match('/keyid="([^"]+)"/', $params, $keyid);
    preg_match('/created=(\d+)/', $params, $created);
    if (abs(time() - (int) $created[1]) > 300) {
        return false;
    }

    // Étape 4 : la base de signature.
    $base = implode("\n", [
        '"@method": POST',
        '"@target-uri": ' . $urlDeRappel,
        '"content-digest": ' . $entetes['content-digest'],
        '"@signature-params": ' . $params,
    ]);

    // Étape 5 : la clé du keyid. Inconnue : rechargez GET /v1/cle-publique.
    $cle = current(array_filter($cles, fn ($c) => $c['keyid'] === $keyid[1]));
    if (!$cle) {
        return false;
    }

    // Étape 6 : openssl attend du DER ; la RFC donne r puis s.
    preg_match('/:(.+):/', $entetes['signature'], $signature);
    $der = brutVersDer(base64_decode($signature[1]));
    return openssl_verify($base, $der, $cle['cle'], OPENSSL_ALGO_SHA256) === 1;
}

function brutVersDer(string $brute): string
{
    $entier = function (string $octets): string {
        $octets = ltrim($octets, "\x00");
        if (ord($octets[0]) > 0x7f) {
            $octets = "\x00" . $octets;
        }
        return "\x02" . chr(strlen($octets)) . $octets;
    };
    $suite = $entier(substr($brute, 0, 32)) . $entier(substr($brute, 32));
    return "\x30" . chr(strlen($suite)) . $suite;
}

// cles : la réponse de GET /v1/cle-publique, gardée en cache.
static boolean verifierRappel(Map<String, String> entetes, byte[] corpsBrut,
        String urlDeRappel, List<CleUmeme> cles) throws Exception {
    // Étape 2 : le corps n'a pas changé en route.
    var condensat = Base64.getEncoder().encodeToString(
        MessageDigest.getInstance("SHA-256").digest(corpsBrut));
    if (!entetes.get("content-digest").equals("sha-256=:" + condensat + ":")) {
        return false;
    }

    // Étape 3 : ce que la signature couvre, quand, avec quelle clé.
    var entree = entetes.get("signature-input");
    var params = entree.substring(entree.indexOf('=') + 1);
    var keyid = extraire(params, "keyid=\"([^\"]+)\"");
    var created = Long.parseLong(extraire(params, "created=(\\d+)"));
    if (Math.abs(Instant.now().getEpochSecond() - created) > 300) {
        return false;
    }

    // Étape 4 : la base de signature.
    var base = String.join("\n",
        "\"@method\": POST",
        "\"@target-uri\": " + urlDeRappel,
        "\"content-digest\": " + entetes.get("content-digest"),
        "\"@signature-params\": " + params);

    // Étape 5 : la clé du keyid. Inconnue : rechargez GET /v1/cle-publique.
    var cle = cles.stream().filter(c -> c.keyid().equals(keyid)).findFirst();
    if (cle.isEmpty()) {
        return false;
    }

    // Étape 6 : Java lit directement la signature brute (r puis s).
    var brute = Base64.getDecoder().decode(extraire(entetes.get("signature"), ":(.+):"));
    var verificateur = Signature.getInstance("SHA256withECDSAinP1363Format");
    verificateur.initVerify(cle.get().publique());
    verificateur.update(base.getBytes(StandardCharsets.UTF_8));
    return verificateur.verify(brute);
}

static String extraire(String texte, String motif) {
    var m = Pattern.compile(motif).matcher(texte);
    if (!m.find()) {
        throw new IllegalArgumentException(motif);
    }
    return m.group(1);
}

à la réception d'un rappel
  si la signature est fausse → répondre 401, ne rien faire
  si evenementId est déjà vu → répondre 200
  enregistrer(evenementId)
  mettre le traitement en file
  // répondre en moins de 30 s
  répondre 200

import express from "express";

import { verifierRappel } from "./verifier-rappel.mjs";

const app = express();

// Le corps reste brut jusqu'à la vérification de la signature.
app.post("/rappels/umeme", express.raw({ type: "application/json" }), async (req, res) => {
  if (!verifierRappel(req.headers, req.body, process.env.URL_DE_RAPPEL, await clesPubliques())) {
    return res.sendStatus(401);
  }
  const evenementId = req.headers["umeme-evenement-id"];
  if (await evenements.dejaVu(evenementId)) {
    return res.sendStatus(200);
  }
  await evenements.enregistrer(evenementId);
  // Le traitement part en file : la réponse doit partir en moins de 30 s.
  await file.ajouter(JSON.parse(req.body));
  res.sendStatus(200);
});

import json
import os

from flask import Flask, request

from verifier_rappel import verifier_rappel

app = Flask(__name__)


@app.post("/rappels/umeme")
def recevoir_rappel():
    # Le corps reste brut jusqu'à la vérification de la signature.
    corps_brut = request.get_data()
    if not verifier_rappel(request.headers, corps_brut, os.environ["URL_DE_RAPPEL"], cles_publiques()):
        return "", 401
    evenement_id = request.headers["Umeme-Evenement-Id"]
    if evenements.deja_vu(evenement_id):
        return "", 200
    evenements.enregistrer(evenement_id)
    # Le traitement part en file : la réponse doit partir en moins de 30 s.
    file.ajouter(json.loads(corps_brut))
    return "", 200

<?php

// Route POST /rappels/umeme. Le corps reste brut jusqu'à la vérification de la signature.
$corpsBrut = file_get_contents('php://input');
$entetes = array_change_key_case(getallheaders(), CASE_LOWER);

if (!verifierRappel($entetes, $corpsBrut, getenv('URL_DE_RAPPEL'), clesPubliques())) {
    http_response_code(401);
    exit;
}
$evenementId = $entetes['umeme-evenement-id'];
if ($evenements->dejaVu($evenementId)) {
    http_response_code(200);
    exit;
}
$evenements->enregistrer($evenementId);
// Le traitement part en file : la réponse doit partir en moins de 30 s.
$file->ajouter(json_decode($corpsBrut, true));
http_response_code(200);

// Spring Boot. Le corps reste brut jusqu'à la vérification de la signature.
@PostMapping("/rappels/umeme")
ResponseEntity<Void> recevoirRappel(@RequestHeader Map<String, String> entetes, @RequestBody byte[] corpsBrut)
        throws Exception {
    if (!verifierRappel(entetes, corpsBrut, urlDeRappel, clesPubliques())) {
        return ResponseEntity.status(401).build();
    }
    var evenementId = entetes.get("umeme-evenement-id");
    if (evenements.dejaVu(evenementId)) {
        return ResponseEntity.ok().build();
    }
    evenements.enregistrer(evenementId);
    // Le traitement part en file : la réponse doit partir en moins de 30 s.
    file.ajouter(new String(corpsBrut, StandardCharsets.UTF_8));
    return ResponseEntity.ok().build();
}

UUID="94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb"

curl -X POST "$UMEME_BASE_URL/ventes/$UUID/rappel" \
  -H "Authorization: Bearer $UMEME_CLE"

// Node.js 18 et plus : fetch est intégré.
const baseUrl = process.env.UMEME_BASE_URL;

const uuid = "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb";

const reponse = await fetch(`${baseUrl}/ventes/${uuid}/rappel`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.UMEME_CLE}`,
  },
});
const donnees = await reponse.json();

// npm install axios
import axios from "axios";

const umeme = axios.create({
  baseURL: process.env.UMEME_BASE_URL,
  headers: { Authorization: `Bearer ${process.env.UMEME_CLE}` },
  timeout: 30000,
});

const uuid = "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb";

const { data } = await umeme.post(`/ventes/${uuid}/rappel`);

import os

import requests

BASE_URL = os.environ["UMEME_BASE_URL"]
ENTETES = {"Authorization": f"Bearer {os.environ['UMEME_CLE']}"}

uuid = "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb"

reponse = requests.post(
    f"{BASE_URL}/ventes/{uuid}/rappel",
    headers=ENTETES,
    timeout=30,
)
donnees = reponse.json()

// composer require guzzlehttp/guzzle
$client = new GuzzleHttp\Client([
    'base_uri' => getenv('UMEME_BASE_URL') . '/',
    'headers' => ['Authorization' => 'Bearer ' . getenv('UMEME_CLE')],
    'timeout' => 30,
]);

$uuid = '94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb';

$reponse = $client->post("ventes/{$uuid}/rappel");
$donnees = json_decode($reponse->getBody(), true);

// Java 15 et plus : java.net.http et blocs de texte.
var baseUrl = System.getenv("UMEME_BASE_URL");
var client = HttpClient.newHttpClient();

var uuid = "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb";

var requete = HttpRequest.newBuilder(URI.create(baseUrl + "/ventes/" + uuid + "/rappel"))
    .header("Authorization", "Bearer " + System.getenv("UMEME_CLE"))
    .POST(HttpRequest.BodyPublishers.noBody())
    .build();

var reponse = client.send(requete, HttpResponse.BodyHandlers.ofString());