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_idoupublisher_idpour 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
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èteK : siK est plus longue queB , elle est pré-hachée à l'aide deH à la longueurL (32 octets) et complétée par des zéros jusqu'àB ; siK est plus courte queB , elle est complétée par des zéros jusqu'àB .\text{opad} est la chaîne de remplissage externe (0x5crépétéB fois).\text{ipad} est la chaîne de remplissage interne (0x36ré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
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

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 majusculesPOST.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.

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 ( |
N'accepte que les horodatages compris dans les |
| 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
Si une requête horodatée à
Pour empêcher cet exploit dans le cadre d'une fenêtre symétrique, ce protocole illustratif adopte une configuration de rétention conservatrice :
Pour une fenêtre de tolérance

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_idoriginal et immuable. Lorsque le réseau partenaire récepteur ingère la requête, il vérifie si l'event_ida 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 NOTHINGlimitée au locataire). S'il a déjà été traité, il renvoie un accusé de réception sans facturation 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éfiWWW-Authenticateapplicable 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.,GETouPUTsur un point de terminaison configuré exclusivement pour les requêtesPOSTsignées). La couche adaptatrice HTTP doit inclure un en-têteAllow: POSTdans 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 ?
Comment les systèmes récepteurs gèrent-ils la dérive d'horloge légitime lors de la validation des postbacks ?
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 ?
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
-
Concepts : Définition d'API, HMAC-SHA256, Défense contre les attaques par rejeu, Nonce cryptographique, Requête canonique, Idempotence métier
-
Technologies : Services web RESTful, HTTPS sur TLS, Authentification de message par hachage avec clé, Mise en cache distribuée en mémoire
-
Normes : Norme HMAC IETF RFC 2104, Sémantique HTTP IETF RFC 9110, Signatures de messages HTTP IETF RFC 9421, Schéma JSON Draft 2020-12
-
API : Authentification de l'API Conversions de Meta, Protocoles de sécurité des conversions hors ligne de Google Ads, Interfaces de vérification HMAC pour Webhooks
-
Documentation officielle et références :
Share this article



