Comment empêcher la falsification des charges utiles d'attribution dans les API S2S sécurisées

opoinstall
2026-11-17
5 min read

Comment empêcher la falsification des charges utiles d'attribution dans les API S2S ? Un récepteur peut détecter les modifications non autorisées apportées aux champs de requête couverts en vérifiant un mécanisme d'authentification de message documenté. La prévention des rejeux de requêtes au niveau de l'application et des crédits de conversion en double nécessite de combiner des contrôles de fraîcheur temporelle, un suivi des nonces atomiques et une idempotence persistante au niveau métier.

Une interface de programmation d'application (API) est une interface définie par laquelle des composants logiciels échangent des données ou demandent des fonctionnalités. Dans l'attribution mobile, les API basées sur HTTP permettent aux plateformes de mesure et aux réseaux partenaires d'échanger des données de conversion via des postbacks de serveur à serveur (S2S). La sécurisation de ces interfaces implique de valider l'intégrité des messages, d'imposer la fraîcheur des requêtes et de maintenir une déduplication métier persistante.

Terme Définition Entité associée Rôle de l'intention de recherche
Postback S2S Une requête HTTP événementielle transportant des données de conversion entre serveurs dorsaux. Rappel Webhook Technique / Informationnel
Code d'authentification de message Une somme de contrôle cryptographique générée avec une clé secrète pour vérifier l'intégrité et l'authenticité des données. HMAC-SHA256 Technique / Sécurité
Défense anti-rejeu Mécanismes empêchant le retraitement frauduleux de requêtes authentiques interceptées. Suivi des nonces Technique / Sécurité
Idempotence métier Logique de traitement garantissant que les transmissions en double d'un même événement ne déclenchent pas plusieurs crédits. Déduplication d'événements Technique / Architectural

Principaux vecteurs de menace ciblant les points de terminaison de postback d'attribution

L'incitatif financier de la falsification des conversions

Dans le marketing à la performance mobile, les enregistrements de conversion en aval dictent directement le règlement financier. Les campagnes à coût par acquisition (CPA) élevé, les dépôts in-app et les événements d'abonnement déterminent les rémunérations des éditeurs et alimentent les modèles d'optimisation automatisés des réseaux partenaires.

Étant donné que les systèmes en aval déclenchent la facturation et l'attribution des crédits sur la base des notifications de postback entrantes, les acteurs malveillants ont tout intérêt à manipuler les attributs de conversion. Sans vérification cryptographique de la charge utile au niveau de l'application, un acteur capable de transmettre des requêtes HTTP valides pourrait modifier les valeurs de conversion, rediriger les identifiants de partenaires ou falsifier des achats inexistants.

Interception, modification et exposition par des intermédiaires

La sécurité de la couche transport (TLS) protège les données en transit entre des pairs de communication TCP immédiats. Cependant, dans les architectures cloud modernes, le TLS est fréquemment terminé au niveau des équilibreurs de charge en périphérie, des passerelles API, des proxys inverses ou des réseaux de diffusion de contenu (CDN) avant que la requête n'atteigne le service dorsal.

Si un proxy intermédiaire est compromis ou si un service de routage non vérifié s'intercale entre l'émetteur et le récepteur, les composants de la requête entrante peuvent être inspectés ou modifiés :

  • Réacheminement d'attribution : Modification de paramètres tels que click_id ou publisher_id pour attribuer une conversion organique à un compte non autorisé.
  • Inflation financière : Modification des numéros de transaction ou des codes de devise dans le corps de la requête pour réclamer des commissions d'affiliation surévaluées.
  • Élévation d'événement : Modification des identifiants de catégorie d'événement, faisant passer des interactions de haut de entonnoir à des jalons d'achat à forte valeur.

Exploits par rejeu par rapport aux livraisons réseau en double

Un exploit par rejeu se produit lorsqu'un adversaire capture une transmission de postback authentique et resoumet cette exact charge utile au récepteur. Étant donné que les paramètres et les jetons cryptographiques du message d'origine étaient authentiques lors de leur génération, les récepteurs naïfs qui se contentent de vérifier la signature du message évaluent les requêtes soumises à nouveau comme valides.

Cette menace doit être distinguée des nouvelles tentatives normales au niveau de la couche transport. Les délais d'attente réseau transitoires amènent souvent un émetteur à retransmettre un postback lorsqu'un accusé de réception HTTP n'est pas reçu, même si le récepteur a déjà ingéré l'enregistrement. Les architectures robustes doivent différencier les rejeux frauduleux des retransmissions bénignes.

Collecte d'informations d'identification et limites des jetons statiques

S'en remettre uniquement à des informations d'identification statiques — telles que des clés API partagées ou des jetons porteurs placés dans les en-têtes de requêtes HTTP — authentifie l'identité de l'appelant en partant du principe que le secret reste confidentiel.

Cependant, les jetons porteurs statiques n'offrent aucune liaison cryptographique avec le corps de la requête. Si une clé statique est divulguée par le biais de journaux de serveur, de configurations erronées de référentiels ou d'outils de surveillance réseau, un attaquant détenant ce jeton peut falsifier des charges utiles arbitraires. Un jeton statique valide qui est censé appeler, mais ne prouve pas si les données transmises ont été modifiées.

Authentification cryptographique des messages et portée de la protection

Mécanisme mathématique du HMAC (IETF RFC 2104)

Un code d'authentification de message par hachage avec clé (HMAC), normalisé dans la RFC 2104 de l'IETF, utilise une fonction de hachage cryptographique (telle que SHA-256) combinée à une clé secrète prépartagée pour vérifier l'intégrité et l'authenticité des données.

L'algorithme HMAC s'applique à une clé secrète K et à un message d'entrée M :

\text{HMAC}(K, M) = H\Big((K' \oplus \text{opad}) \parallel H\big((K' \oplus \text{ipad}) \parallel M\big)\Big)

Où :

  • H est la fonction de hachage cryptographique sous-jacente (SHA-256).
  • B est la taille de bloc de la fonction de hachage (64 octets pour SHA-256).
  • K' est dérivé de la clé secrète K : si K est plus longue que B, elle est pré-hachée à l'aide de H à la longueur L (32 octets) et complétée par des zéros jusqu'à B ; si K est plus courte que B, elle est complétée par des zéros jusqu'à B.
  • \text{opad} est la chaîne de remplissage externe (0x5c répété B fois).
  • \text{ipad} est la chaîne de remplissage interne (0x36 répété B fois).
  • \parallel désigne la concaténation d'octets, et \oplus désigne l'opération OU exclusif bit à bit.

Bien que la documentation sectorielle qualifie fréquemment ce mécanisme de « signature de requête », le HMAC est un code d'authentification de message (MAC) symétrique. Il ne fournit pas de signatures numériques asymétriques ni de non-répudiation cryptographique, car l'émetteur et le récepteur partagent tous deux l'accès à la même clé secrète K.

Portée et limites de l'authentification des messages

L'établissement de limites claires autour de la vérification cryptographique évite de surestimer les résultats en matière de sécurité :

Limite de vérification Capacité opérationnelle réelle
Ce qu'un MAC valide prouve 1. Les éléments du message couvert correspondent exactement aux octets hachés par l'émetteur.
2. La partie générant le MAC possédait la clé secrète partagée active.
Ce qu'un MAC ne prouve pas 1. Que l'achat in-app ou l'installation a réellement eu lieu sur un véritable appareil.
2. Que l'émetteur n'a pas fabriqué d'événements commerciaux frauduleux.
3. Que le secret partagé n'a pas été exposé ou partagé en interne.
4. Que la requête n'a pas été interceptée et retransmise (rejeu).

Un MAC valide authentifie les données de requête couvertes sous la clé configurée. Il n'établit pas que la conversion signalée s'est produite ; les enregistrements commerciaux faisant foi, l'autorisation, le rapprochement et l'idempotence des événements demeurent des contrôles distincts.

Sécurité des transports par rapport à la sécurité des applications

Le protocole TLS protège le transport du postback tandis que le HMAC détecte la falsification des champs de requête authentifiés.

L'authentification des messages au niveau de l'application ne remplace pas la sécurité de la couche transport (TLS). Le protocole TLS fonctionnant entre pairs TCP immédiats protège les informations d'identification, les en-têtes et les charges utiles contre l'écoute clandestine passive sur l'Internet public. À son tour, l'authentification des messages au niveau de l'application garantit que même si le TLS se termine au niveau d'un proxy inverse intermédiaire ou d'une passerelle en périphérie, les modifications non autorisées apportées aux champs couverts peuvent être détectées et rejetées avant d'atteindre la logique d'exécution de l'application.

Construction du modèle de données canonique signé

Le risque des champs de requête non couverts

Un MAC cryptographique protège uniquement la séquence d'octets spécifique injectée dans la fonction de hachage. Tel que formalisé dans la RFC 9421 de l'IETF (Signatures de messages HTTP), tout composant de requête omis de la base de signature peut être modifié ou injecté en transit sans invalider la balise d'authentification.

Dans les postbacks d'attribution S2S HTTP, omettre le chemin URI, l'identifiant de clé ou les paramètres de requête autorise la manipulation des paramètres tout en maintenant une signature valide sur le corps de la requête seul :

  • Falsification de la chaîne de requête : Dans un postback HTTP GET, ou une requête POST transportant des paramètres de requête d'URL, laisser les paramètres de requête hors de la chaîne canonique permet à un adversaire de modifier ces paramètres de requête à sa guise.
  • Traversée de chemin et réacheminement de point de terminaison : Omettre le chemin cible permet à un adversaire de prendre une charge utile destinée à un point de terminaison de test (/v1/test/conversion) et de la transférer vers un point de terminaison de facturation de production (/v1/live/conversion).
  • Substitution de l'identifiant de clé : Omettre l'ID de clé permet à un adversaire de réacheminer les requêtes si la recherche de clés et l'identité du locataire ne sont pas solidement liées, ou si le même matériel secret est partagé de manière inappropriée entre plusieurs portées de locataires.

Définition d'un schéma de requête S2S illustratif

Pour normaliser la vérification, les systèmes doivent établir un format de chaîne canonique clair. Le schéma suivant illustre une charge utile de conversion JSON POST avec des identifiants de transaction dédiés et des paramètres optionnels de suivi monétaire :

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "IllustrativeConversionPostbackPayload",
  "type": "object",
  "required": [
    "event_id",
    "event_name",
    "event_timestamp"
  ],
  "properties": {
    "event_id": {
      "type": "string",
      "minLength": 1,
      "description": "Identifiant unique d'événement de transaction utilisé par les systèmes récepteurs pour la déduplication au niveau métier."
    },
    "click_id": {
      "type": ["string", "null"],
      "description": "Identifiant d'attribution sans état correspondant à un enregistrement de clic publicitaire. Nullable pour les événements organiques ou agrégés."
    },
    "campaign_id": {
      "type": ["string", "null"],
      "description": "Identifiant de suivi de campagne fourni lors de l'ingestion initiale du clic."
    },
    "event_name": {
      "type": "string",
      "minLength": 1,
      "description": "Identifiant d'événement normalisé (par ex., install, purchase, registration)."
    },
    "event_timestamp": {
      "type": "integer",
      "minimum": 0,
      "description": "Horodatage d'époque en secondes entières représentant le moment où l'événement commercial s'est produit."
    },
    "conversion_value": {
      "type": "number",
      "description": "Revenu monétaire optionnel associé à l'événement."
    },
    "currency": {
      "type": "string",
      "pattern": "^[A-Z]{3}$",
      "description": "Chaîne de formatage de devise à trois lettres. La validation sémantique par rapport à la norme ISO 4217 doit être appliquée par la logique applicative."
    }
  },
  "dependentRequired": {
    "conversion_value": ["currency"]
  }
}

Normalisation du protocole canonique

Pour éviter les échecs de vérification causés par des variations de formatage entre les systèmes, l'émetteur et le récepteur doivent assembler une chaîne UTF-8 normalisée et délimitée.

Note sur les limites du protocole : La construction suivante définit un profil MAC illustratif défini par l'application pour les requêtes POST JSON ciblant un chemin exact. Il ne s'agit pas de la spécification de protocole officielle des signatures de messages HTTP de l'IETF RFC 9421 ni d'un protocole officiel OpoInstall. Les intégrateurs doivent documenter et appliquer leurs propres règles de canonisation.

CanonicalString = HTTP_METHOD + "\n" +
                  REQUEST_PATH + "\n" +
                  KEY_ID + "\n" +
                  TIMESTAMP_SECONDS + "\n" +
                  NONCE + "\n" +
                  HEX_SHA256(RAW_BODY_BYTES)

Règles d'assemblage de chaque composant canonique de ce profil :

  • HTTP_METHOD : Doit être strictement en majuscules POST.
  • REQUEST_PATH : Le chemin URI cible exact (par ex., /v1/conversions/postback). Pour éliminer toute ambiguïté de normalisation des requêtes, les paramètres de requête d'URL ne sont pas autorisés sur ce point de terminaison.
  • KEY_ID : L'identifiant de la clé prépartagée (par ex., key_demo_2026). Lié directement dans la chaîne canonique pour empêcher les attaques par substitution de clé.
  • TIMESTAMP_SECONDS : L'horodatage d'envoi de la requête formaté en entier en base 10 représentant les secondes d'époque.
  • NONCE : Une chaîne hexadécimale cryptographiquement aléatoire (minimum 32 caractères hexadécimaux minuscules, générée via un CSPRNG) propre à cet envoi de requête HTTP.
  • RAW_BODY_BYTES: Le flux d'octets exact du corps de la requête. Le condensé SHA-256 est calculé directement sur ces octets.

Les champs de requête canoniques et un secret partagé produisent une balise d'authentification HMAC.

Défense anti-rejeu multicouche et idempotence

Responsabilités tout au long du pipeline de vérification des requêtes

Étape de traitement Contrôle défensif Responsabilité opérationnelle
1. Transport et syntaxe des requêtes Limites de méthode, de chemin et de taille de corps Vérifie que la requête correspond à la méthode HTTP et au chemin autorisés, et ne dépasse pas les limites de mémoire.
2. Vérification de la fraîcheur Fenêtre d'horodatage bornée (\Delta t \le W) N'accepte que les horodatages compris dans les W secondes précédant ou suivant l'heure du récepteur ($
3. Identité et liaison de clé Recherche dans le registre de clés de confiance Résout la clé secrète partagée à partir d'un magasin dorsal de confiance à l'aide de X-Key-Id. Rejette les clés inconnues avant l'évaluation cryptographique.
4. Authentification des messages Validation HMAC-SHA256 à temps constant Calcule le MAC sur la chaîne canonique et le compare à X-Signature à l'aide de compare_digest.
5. Protection anti-rejeu atomique Cache de nonces cloisonné (SET key NX EX) Réserve de manière atomique le nonce dans le cache sous la portée de la clé du locataire authentifié pour la durée de la fenêtre de rétention.
6. Déduplication métier Contrainte d'unicité de base de données transactionnelle Empêche les crédits en double lorsque la déduplication d'événements et les mises à jour de crédits sont validées de manière atomique dans les limites du locataire.

Tolérances de dérive temporelle et configuration de la rétention des nonces

L'atténuation des exploits par rejeu nécessite de coordonner deux contrôles interdépendants : une fenêtre d'horodatage bornée et un cache de nonces atomique.

Considérons une intégration avec une tolérance de dérive d'horloge symétrique W = 300\text{ seconds} où le serveur accepte les requêtes comprises entre :

t_{\text{recv}} - W \le t_{\text{req}} \le t_{\text{recv}} + W

Si une requête horodatée à t_{\text{req}} = 1000 arrive alors que l'horloge du récepteur indique t_{\text{recv}} = 700 (autorisé car 1000 - 700 \le 300), et que le nonce est stocké avec une durée de vie (TTL) de 300 secondes, la clé de cache expire à t = 1000. Si l'adversaire retransmet la requête identique à t = 1001, la requête est désormais âgée de 1 seconde (1001 - 1000 = 1 \le 300), ce qui valide le contrôle de fraîcheur. Le nonce ayant expiré du cache à t = 1000, la requête rejouée aboutit.

Pour empêcher cet exploit dans le cadre d'une fenêtre symétrique, ce protocole illustratif adopte une configuration de rétention conservatrice :

\text{TTL}_{\text{nonce}} = 2 \times W + \text{ClockSkewMargin}

Pour une fenêtre de tolérance W = 300\text{s} et une marge de décalage d'horloge de 60\text{s}, le TTL du nonce est configuré à 660\text{ seconds}. Alternativement, les récepteurs peuvent appliquer une politique de dérive asymétrique (par ex., rejetant les horodatages futurs dépassant 5 secondes) et définir le TTL du nonce à W + \text{FutureMargin}.

Les contrôles d'horodatage et le suivi atomique des nonces empêchent l'acceptation répétée de requêtes signées.

Suivi des nonces atomiques et politiques en cas de mode dégradé

La vérification du nonce et sa réservation doivent s'exécuter sous la forme d'une opération atomique. Effectuer une requête de lecture séparée suivie d'une requête d'écriture introduit une condition de course (du moment de la vérification au moment de l'utilisation) qui permet des attaques par rejeu simultanées.

Dans les architectures distribuées, la réservation atomique est mise en œuvre à l'aide de primitives de bases de données en mémoire, telles que SET key value EX ttl NX de Redis. Pour empêcher toute collision inter-locataire ou pollution inter-clé, la clé de cache doit être cloisonnée par la clé authentifiée ou l'identifiant du locataire (par ex., s2s_nonce:{key_id}:{nonce}).

Les administrateurs système doivent définir des politiques d'échec explicites pour le cas où le cache distribué serait injoignable :

  • Politique d'échec fermé (Fail-Closed) : Rejette les postbacks entrants avec un code d'état HTTP 503 si le cache de nonces est hors ligne. Cela empêche les attaques par rejeu lors de pannes d'infrastructure mais interrompt l'ingestion des conversions.
  • Politique d'échec ouvert (Fail-Open) avec journalisation : Laisse temporairement passer les signatures vérifiées tout en consignant une alerte. Cela préserve la disponibilité de l'ingestion, mais les opérateurs doivent accepter que la protection contre les rejeux de transport soit dégradée jusqu'à ce que le cache récupère.

Rejeux de transport et idempotence métier

La sécurité des applications doit dissocier la gestion des nouvelles tentatives au niveau de la couche transport du traitement des événements au niveau de la couche métier :

  • Couche transport (Nonce et horodatage) : Sécurise un envoi HTTP unique. Si un délai d'attente réseau se produit et que l'émetteur réessaie le postback, il doit générer un nouvel horodatage, un nouveau nonce et recalculer le HMAC sur la chaîne canonique mise à jour.
  • Couche métier (ID d'événement) : Sécurise l'enregistrement de conversion. Le corps de la charge utile conserve l'event_id original et immuable. Lorsque le réseau partenaire récepteur ingère la requête, il vérifie si l'event_id a déjà été crédité au sein d'une transaction de base de données persistante (par ex., via une contrainte d'unicité INSERT ... ON CONFLICT DO NOTHING limitée au locataire). S'il a déjà été traité, il renvoie un accusé de réception sans facturation en double.

Les nonces de requête distincts préservent les nouvelles tentatives légitimes tandis que l'idempotence de la base de données empêche les crédits de conversion en double.

Implémentation de référence : Schéma d'en-tête cryptographique et vérification

Représentation des en-têtes et de la charge utile au niveau du protocole

L'échange HTTP auto-cohérent suivant illustre une requête de postback de conversion authentifiée utilisant des en-têtes cryptographiques découplés.

La requête utilise la clé secrète de test b"k_demo_secret_key_32_bytes_len!", l'en-tête X-Key-Id key_demo_2026, l'horodatage 1794815760 (correspondant au 2026-11-16T07:56:00Z) et le nonce 4e9a2c1b74e64f8e9b2a1c74e6f8a9b2.

Les octets du corps UTF-8 brut (JSON compact, exactement 207 octets) sont : {"event_id":"evt_9876543210_abc","click_id":"click_123456789_xyz","campaign_id":"cmp_spring_acquisition","event_name":"in_app_purchase","event_timestamp":1794815758,"conversion_value":49.99,"currency":"USD"}

Le calcul de SHA-256(raw_body_bytes) donne : eda92f236690851c47e5662feb02a6d3aa144e6d7061bf41c4b41a4f43a0a9ba

Assemblage de la chaîne canonique :

POST
/v1/conversions/postback
key_demo_2026
1794815760
4e9a2c1b74e64f8e9b2a1c74e6f8a9b2
eda92f236690851c47e5662feb02a6d3aa144e6d7061bf41c4b41a4f43a0a9ba

Le calcul de HMAC-SHA256(key, canonical_string) donne la signature hexadécimale exacte : a0c399934b8bde268d5deedb879b2f06ff8d9df0b51dd5957fd1014a8e1429fc

La transmission sur le réseau et l'accusé de réception immédiat :

POST /v1/conversions/postback HTTP/1.1
Host: api.adnetwork-receiver.example.com
Content-Type: application/json
X-Key-Id: key_demo_2026
X-Signature-Version: v1
X-Timestamp: 1794815760
X-Nonce: 4e9a2c1b74e64f8e9b2a1c74e6f8a9b2
X-Signature: a0c399934b8bde268d5deedb879b2f06ff8d9df0b51dd5957fd1014a8e1429fc

{"event_id":"evt_9876543210_abc","click_id":"click_123456789_xyz","campaign_id":"cmp_spring_acquisition","event_name":"in_app_purchase","event_timestamp":1794815758,"conversion_value":49.99,"currency":"USD"}
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 16 Nov 2026 07:56:01 GMT

{
  "status": "acknowledged",
  "event_id": "evt_9876543210_abc"
}

Logique de vérification défensive en Python

L'implémentation suivante représente un composant de référence pour la couche d'authentification. Notez que request_target doit être extrait directement de la ligne de requête HTTP brute, en préservant tout élément de chemin et de requête afin que les chaînes de requête non autorisées soient rejetées. Les préoccupations liées au niveau de l'application — telles que la validation du Content-Type, l'autorisation des locataires et la désérialisation du schéma — doivent être évaluées par un middleware en aval avant que les transactions ne soient validées :

import hmac
import hashlib
import time
import re
from typing import Optional, Dict

# Configuration Constants
ALLOWED_SIGNATURE_VERSIONS = {"v1"}
HEX_64_PATTERN = re.compile(r"^[0-9a-f]{64}$")
TIMESTAMP_PATTERN = re.compile(r"^\d{1,10}$")
HEX_NONCE_PATTERN = re.compile(r"^[0-9a-f]{32,64}$")

DRIFT_WINDOW_SECONDS = 300
SKEW_MARGIN_SECONDS = 60
NONCE_TTL_SECONDS = (DRIFT_WINDOW_SECONDS * 2) + SKEW_MARGIN_SECONDS
MAX_BODY_SIZE_BYTES = 1024 * 64  # 64 KB limit
EXPECTED_REQUEST_PATH = "/v1/conversions/postback"

# Mock Trusted Key Registry (In production, load securely from Vault / KMS)
TRUSTED_KEY_REGISTRY: Dict[str, bytes] = {
    "key_demo_2026": b"k_demo_secret_key_32_bytes_len!"
}

class VerificationResult:
    def __init__(self, valid: bool, status_code: int, error_code: str):
        self.valid = valid
        self.status_code = status_code
        self.error_code = error_code

def verify_s2s_postback_authentication(
    headers: dict,
    http_method: str,
    request_target: str,
    raw_body_bytes: bytes,
    redis_client
) -> VerificationResult:
    """
    Reference authentication-layer verifier for S2S postback requests.
    Enforces strict method/path rules, validates headers, checks freshness,
    verifies HMAC-SHA256, and atomically reserves the scoped nonce in Redis.
    """
    # 1. Payload Size Guard
    if len(raw_body_bytes) > MAX_BODY_SIZE_BYTES:
        return VerificationResult(False, 413, "PAYLOAD_TOO_LARGE")

    # 2. Strict Method and Target Path Enforcement (No query strings allowed)
    if http_method.upper().strip() != "POST":
        return VerificationResult(False, 405, "METHOD_NOT_ALLOWED")

    normalized_target = request_target.strip()
    if normalized_target != EXPECTED_REQUEST_PATH:
        return VerificationResult(False, 404, "INVALID_REQUEST_PATH")

    # 3. Header Extraction and Syntax Validation
    sig_version = headers.get("X-Signature-Version", "")
    if sig_version not in ALLOWED_SIGNATURE_VERSIONS:
        return VerificationResult(False, 400, "UNSUPPORTED_SIGNATURE_VERSION")

    key_id = headers.get("X-Key-Id", "").strip()
    if not key_id or len(key_id) > 64 or not key_id.isascii():
        return VerificationResult(False, 400, "INVALID_KEY_ID_FORMAT")

    # 4. Resolve Trusted Secret Key from Authenticated Registry
    secret_key = TRUSTED_KEY_REGISTRY.get(key_id)
    if not secret_key:
        return VerificationResult(False, 401, "UNKNOWN_OR_INACTIVE_KEY")

    received_sig = headers.get("X-Signature", "").strip().lower()
    if not received_sig.isascii() or not HEX_64_PATTERN.match(received_sig):
        return VerificationResult(False, 400, "MALFORMED_SIGNATURE_HEADER")

    timestamp_str = headers.get("X-Timestamp", "").strip()
    if not timestamp_str.isascii() or not TIMESTAMP_PATTERN.match(timestamp_str):
        return VerificationResult(False, 400, "MALFORMED_TIMESTAMP_HEADER")

    nonce = headers.get("X-Nonce", "").strip().lower()
    if not nonce.isascii() or not HEX_NONCE_PATTERN.match(nonce):
        return VerificationResult(False, 400, "INVALID_NONCE_FORMAT")

    # 5. Time-Drift Freshness Check
    req_timestamp = int(timestamp_str)
    current_time = int(time.time())
    if abs(current_time - req_timestamp) > DRIFT_WINDOW_SECONDS:
        return VerificationResult(False, 401, "EXPIRED_OR_PREDATED_TIMESTAMP")

    # 6. Canonical String Construction (Explicitly binding Method, Path, Key ID, Timestamp, Nonce, Body)
    body_digest = hashlib.sha256(raw_body_bytes).hexdigest()
    canonical_string = (
        f"POST\n"
        f"{EXPECTED_REQUEST_PATH}\n"
        f"{key_id}\n"
        f"{timestamp_str}\n"
        f"{nonce}\n"
        f"{body_digest}"
    )

    # 7. Cryptographic MAC Calculation (RFC 2104 / SHA-256)
    computed_mac = hmac.new(
        secret_key,
        canonical_string.encode("utf-8"),
        hashlib.sha256
    ).hexdigest()

    # Constant-time comparison to mitigate timing attacks
    if not hmac.compare_digest(received_sig, computed_mac):
        return VerificationResult(False, 401, "SIGNATURE_VERIFICATION_FAILED")

    # 8. Scoped Atomic Nonce Registration (Bound to Key ID; executed AFTER signature check)
    scoped_nonce_key = f"s2s_nonce:{key_id}:{nonce}"
    try:
        is_unique = redis_client.set(
            scoped_nonce_key,
            "1",
            ex=NONCE_TTL_SECONDS,
            nx=True
        )
        if not is_unique:
            return VerificationResult(False, 401, "REPLAYED_TRANSACTION_NONCE")
    except Exception:
        # Fail-closed policy: reject request when nonce storage is unavailable
        return VerificationResult(False, 503, "NONCE_STORAGE_UNAVAILABLE")

    return VerificationResult(True, 200, "SUCCESS")

Sémantique des codes d'état HTTP pour les échecs de vérification de sécurité

La normalisation des réponses de statut HTTP permet un audit de diagnostic tout en respectant les normes de protocole :

  • 400 Bad Request : Indique des malformations syntaxiques ou structurelles dans la transmission de la requête. Renvoyé lorsque les en-têtes de sécurité obligatoires sont absents, que l'encodage de la chaîne enfreint les règles ASCII ou que les valeurs hexadécimales violent les motifs de format.
  • 401 Unauthorized : Indique un échec d'authentification ou cryptographique. Renvoyé lorsque l'identifiant de clé n'est pas reconnu, que le calcul HMAC ne correspond pas à la signature entrante, que l'horodatage enfreint les limites de dérive, ou que le nonce est identifié comme un double. Lors de la génération d'une réponse 401, la couche adaptatrice HTTP doit inclure un en-tête de défi WWW-Authenticate applicable conforme à la RFC 9110 de l'IETF.
  • 403 Forbidden : Indique que bien que la signature cryptographique et l'horodatage aient été vérifiés avec succès sous la clé, le locataire authentifié manque d'autorisations pour les ressources de campagne ou d'éditeur spécifiques identifiées dans le corps.
  • 405 Method Not Allowed : Renvoyé lorsque la requête utilise un verbe HTTP non pris en charge (par ex., GET ou PUT sur un point de terminaison configuré exclusivement pour les requêtes POST signées). La couche adaptatrice HTTP doit inclure un en-tête Allow: POST dans la réponse.
  • 413 Payload Too Large : Renvoyé lorsque le corps de la requête dépasse la limite d'octets maximale configurée (par ex., 64 Ko).
  • 422 Unprocessable Content : Indique que bien que les en-têtes cryptographiques aient été vérifiés avec succès, le corps de la charge utile JSON enfreint les règles sémantiques (par exemple, absence d'un code de devise ISO obligatoire lorsqu'une valeur de revenu d'événement est transmise).

Évaluation comparative des contrôles de sécurité S2S

La sélection des mécanismes de sécurité appropriés nécessite d'évaluer les couches de défense par rapport à des limites opérationnelles spécifiques :

Contrôle Sécurité de connexion TLS Intégrité de la charge utile applicative Défense anti-rejeu de requêtes applicatives Déduplication d'événements métier
Jeton porteur statique sur HTTPS Fourni par le TLS entre pairs immédiats Aucune ; charge utile non protégée à travers les proxys intermédiaires Aucune ; jetons porteurs réutilisables pendant la période de validité Nécessite une contrainte d'unicité de base de données distincte
Liste blanche d'adresses IP Aucune ; contrôle de routage réseau uniquement Aucune ; paquets non authentifiés au niveau de l'application Aucune ; requêtes réutilisables à partir d'adresses IP autorisées Nécessite une contrainte d'unicité de base de données distincte
HMAC-SHA256 applicatif Aucune ; fonctionne au niveau de l'application Authentifie les éléments canoniques couverts sous la clé Dépendant de mécanismes externes d'horodatage et de nonce Nécessite une contrainte d'unicité de base de données distincte
TLS mutuel (mTLS) Authentification cryptographique des pairs et du transport Niveau tunnel ; ne protège pas contre les rejeux au niveau de l'application Aucune ; requêtes réutilisables au niveau de l'application Nécessite une contrainte d'unicité de base de données distincte
Architecture en couches (mTLS + HMAC + Nonce + Clé unique de BDD) Authentification cryptographique des pairs sur le réseau Intégrité de la charge utile de bout en bout à travers les intermédiaires Appliquée via des limites d'horodatage et un cache de nonces atomique Appliquée via des contraintes de base de données transactionnelles

Foire aux questions (FAQ)

Quelle est la différence entre une clé API et une signature HMAC dans la sécurité S2S ?
Une clé API statique est un identifiant porteur persistant envoyé dans les en-têtes HTTP qui authentifie l'identité de l'appelant mais n'offre aucune vérification de l'intégrité du message. Une signature HMAC est un hachage cryptographique dynamique calculé par requête à l'aide d'une clé secrète prépartagée, d'un horodatage, d'un nonce unique et du corps de la charge utile brute. Si un paramètre de la charge utile est modifié en transit, le HMAC calculé change, ce qui amène le récepteur à rejeter immédiatement la requête falsifiée.
Comment les systèmes récepteurs gèrent-ils la dérive d'horloge légitime lors de la validation des postbacks ?
Dans ce protocole illustratif, les systèmes récepteurs configurent une fenêtre de tolérance de dérive temporelle symétrique ($\pm 300\text{ seconds}$) pour tenir compte des mineurs écarts d'horloge entre les instances cloud distribuées. Si l'horodatage du postback se situe dans cette fenêtre, le récepteur évalue la signature. Si l'horodatage s'écarte au-delà du seuil configuré, la requête est immédiatement rejetée avec un code d'état HTTP 401 Unauthorized, empêchant les requêtes expirées ou prédatées d'entrer dans les pipelines de traitement.
Pourquoi la mise en liste blanche d'adresses IP est-elle insuffisante en tant que contrôle de sécurité autonome pour les API d'attribution ?
Bien que la liste blanche d'adresses IP restreigne l'accès réseau aux sous-réseaux de serveurs approuvés, elle ne parvient pas à authentifier les locataires applicatifs spécifiques derrière des proxys partagés, ne vérifie pas l'intégrité des données de la charge utile et s'avère fragile sur le plan opérationnel face aux pools d'adresses IP cloud dynamiques. Les environnements cloud modernes utilisent fréquemment des plages d'adresses IP sortantes dynamiques, ce qui rend les listes blanches d'adresses IP statiques insuffisantes en l'absence de vérification cryptographique au niveau de l'application.

Résumé et cadre de décision

Empêcher la falsification des charges utiles d'attribution dans les API de serveur à serveur nécessite de s'affranchir des identifiants statiques et des webhooks non authentifiés. En mettant en œuvre une architecture cryptographique au niveau de l'application qui combine la normalisation des chaînes canoniques, le hachage HMAC-SHA256, des contrôles d'horodatage bornés et la réservation de nonces atomiques, les systèmes de mesure établissent une intégrité vérifiable des données et atténuent les exploits par rejeu.

La validation cryptographique confirme que les données de conversion entrantes correspondent exactement à la charge utile construite par l'émetteur détenant le secret prépartagé. Cependant, l'authentification des messages ne vérifie pas la légitimité réelle sous-jacente de la conversion. Les architectures d'attribution d'entreprise doivent associer la signature de requêtes à l'idempotence au niveau métier, à l'audit des valeurs de conversion et au rapprochement côté serveur pour maintenir des systèmes d'attribution résilients.

Les équipes se préparant à configurer des intégrations de suivi de campagnes et à examiner les spécifications d'API peuvent consulter le centre de documentation OpoInstall, gérer les identifiants d'application sur la console développeur OpoInstall ou examiner la référence d'implémentation de l'attribution mobile plus générale pour obtenir des conseils architecturaux.

Matériels associés

Share this article