ThunderPhone v3 இப்போது கிடைக்கிறது.நீங்களே தொடங்கலாம்; நிமிடத்திற்கு 2¢ முதல்.அறிவிப்பைப் படிக்கவும்

Operations

வெப்ஹூக் கையொப்பங்களைச் சரிபார்க்கவும்

ThunderPhone அனுப்பும் ஒவ்வொரு வெப்ஹூக் மற்றும் கருவி கோரிக்கையும் நேரமுத்திரையுடன் கையொப்பமிடப்படும். இங்குள்ள ரெசிபி அல்லது SDK உதவியைப் பயன்படுத்தி அதைச் சரிபார்த்து, ஐந்து நிமிடங்களுக்கும் மேலான மீள்இயக்கக் கோரிக்கைகளை நிராகரிக்கவும்.

உங்கள் சர்வருக்கு நாங்கள் அனுப்பும் ஒவ்வொரு கோரிக்கையிலும் (webhook அனுப்புதல்கள், பழைய ஒற்றை-URL webhook மற்றும் கருவி-endpoint அழைப்புகள்) இரண்டு கையொப்ப தலைப்புகள் இருக்கும். இரண்டும் ஒரே ரகசியத்துடன் HMAC-SHA256 ஆகும்.

தலைப்புகையொப்பமிடுவதுமீள்இயக்கப் பாதுகாப்பு
X-ThunderPhone-Signature-V2 (பரிந்துரைக்கப்படுகிறது)நேரமுத்திரை, முறை, பாதை, வினவல் மற்றும் உடல்5 நிமிடங்களுக்கு மேல் பழைய கோரிக்கைகளை நிராகரிக்கவும்
X-ThunderPhone-Signatureஉடல் மட்டும்இல்லை: கைப்பற்றப்பட்ட கோரிக்கை எப்போதும் சரிபார்க்கப்படும்

புதிய ஒருங்கிணைப்புகளில் X-ThunderPhone-Signature-V2-ஐச் சரிபார்த்து, ஏற்கனவே உள்ளவற்றை அதற்கு மாற்றவும். X-ThunderPhone-Signature ஒவ்வொரு கோரிக்கையிலும் மாற்றமின்றி இன்னும் அனுப்பப்படுகிறது; எனவே அதனை அடிப்படையாகக் கொண்ட சரிபார்ப்பிகள் தொடர்ந்து செயல்படும். அதை அனுப்புவதை நிறுத்துவதற்கு முன் ஒரு தேதியை அறிவிப்போம்.

கையொப்பம் V2

X-ThunderPhone-Signature-V2: t=1767225600,v1=03a89bec521f78d55727237ca4713bb0b8dcdf2e09e450865b5b5637b80c1c4e
  • t என்பது நாங்கள் கோரிக்கையை அனுப்பிய நேரத்தின் Unix நேரம்; இது விநாடிகளில் இருக்கும். மீண்டும் முயற்சிக்கும் விநியோகம் அனுப்பப்படும்போது, அதன் சொந்த t உடன் மீண்டும் கையொப்பமிடப்படும்.
  • v1 என்பது கீழே உள்ள கையொப்பமிடப்பட்ட சரத்தின் ஹெக்ஸ் HMAC-SHA256 ஆகும்; இது உங்கள் ரகசியத்தைக் கொண்டு உருவாக்கப்படுகிறது.

மதிப்பு என்பது காற்புள்ளிகளால் பிரிக்கப்பட்ட key=value இணைகளின் பட்டியல். நீங்கள் அறியாத விசைகளைப் புறக்கணிக்கவும்; ஏதேனும் ஒரு v1 பொருந்தினால் கோரிக்கையை ஏற்கவும்: எதிர்கால மாற்றத்தின்போது நாங்கள் இரண்டாவது கையொப்பத்தைச் சேர்க்கலாம்.

கையொப்பமிடப்பட்ட சரம்

நான்கு புலங்கள்; கடைசியைத் தவிர ஒவ்வொன்றுக்கும் பிறகு ஒரு புதியவரி (\n, பைட் 0x0A):

<t>\n<METHOD>\n<path and query>\n<body>
புலம்மதிப்பு
tஹெடரிலிருந்து வரும் t மதிப்பு
METHODபெரிய எழுத்துகளில் உள்ள HTTP முறை: POST, GET, PUT, PATCH அல்லது DELETE
பாதை மற்றும் வினவல்HTTP கோரிக்கை வரியிலிருந்து வரும் கோரிக்கை இலக்கு: முதலில் பாதை, பின்னர் ஒன்று இருந்தால் ? மற்றும் வினவல் சரம். ஸ்கீம், ஹோஸ்ட் அல்லது ஃபிராக்மென்ட் இல்லை. டிகோட் செய்யாமலும் அளவுருக்களை மறுவரிசைப்படுத்தாமலும், வந்தபடியே பயன்படுத்தவும்
bodyமூல கோரிக்கை உடல். GET மற்றும் DELETE கருவி அழைப்புகளுக்கு உடல் இருக்காது; எனவே அவற்றின் கையொப்பமிடப்பட்ட சரம் பாதைக்குப் பின் வரும் புதியவரியுடன் முடியும்

சரிபார்க்க:

  1. எந்தப் பார்சிங்கிற்கும் முன், ஹெடர், முறை, மூல பாதை மற்றும் வினவல், மற்றும் மூல உடலைப் படிக்கவும்.
  2. ஹெடரிலிருந்து t மற்றும் ஒவ்வொரு v1 ஐயும் எடுக்கவும்.
  3. t உங்கள் கடிகாரத்திற்கு முன்போ பின்போ 300 விநாடிகளுக்கு அதிகமாக இருந்தால் கோரிக்கையை நிராகரிக்கவும்.
  4. உங்கள் ரகசியத்தைக் கொண்டு கையொப்பமிடப்பட்ட சரத்தின் ஹெக்ஸ் HMAC-SHA256 ஐக் கணக்கிடவும்.
  5. அதை v1 உடன் மாறாத நேரத்தில் ஒப்பிடவும். எதுவும் பொருந்தவில்லை என்றால் 401 பதிலளிக்கவும்.

செயல்படுத்தப்பட்ட எடுத்துக்காட்டு

ரகசியம் whsec_example_4c1f2a9b. இந்தக் கோரிக்கையை t = 1767225600 (2026-01-01 00:00:00 UTC) நேரத்தில் அனுப்புகிறோம்:

POST /tools/lookup?region=us HTTP/1.1
Host: api.example.com
Content-Type: application/json
X-ThunderPhone-Signature-V2: t=1767225600,v1=03a89bec521f78d55727237ca4713bb0b8dcdf2e09e450865b5b5637b80c1c4e
 
{"customer_id":"cust_123"}

கையொப்பமிடப்பட்ட சரம் இந்த நான்கு வரிகளாகும்; உடலுக்குப் பிறகு புதியவரி இல்லை:

1767225600
POST
/tools/lookup?region=us
{"customer_id":"cust_123"}

இதன் HMAC-SHA256 03a89bec521f78d55727237ca4713bb0b8dcdf2e09e450865b5b5637b80c1c4e. இதற்கு எதிராக உங்கள் செயலாக்கத்தைச் சரிபார்க்கவும் அல்லது openssl மூலம் மீண்டும் உருவாக்கவும்:

printf '1767225600\nPOST\n/tools/lookup?region=us\n{"customer_id":"cust_123"}' \
  | openssl dgst -sha256 -hmac 'whsec_example_4c1f2a9b'

அதே விநாடியில் /tools/lookup?customer_id=cust_123 க்கான GET கருவி அழைப்புக்கு வெற்று உடல் இருக்கும். அதன் கையொப்பமிடப்பட்ட சரம் 1767225600\nGET\n/tools/lookup?customer_id=cust_123\n; அதன் கையொப்பம் 3ce214cb0b8f2bf39b1d19d4e7265df9dbaff5a5f838d3cc6c753a8f7a4ad280.

SDKகளுடன்

Python மற்றும் TypeScript SDKகளில் ஒரு உதவியாளர் உள்ளது (thunderphone 0.2.0 அல்லது அதற்குப் பிந்தையது, @thunderphone/sdk 0.2.0 அல்லது அதற்குப் பிந்தையது). இது 5 நிமிடச் சாளரத்தைச் சரிபார்க்கிறது, மாறாத நேரத்தில் ஒப்பிடுகிறது, மேலும் செயலிழப்பு நேரமின்றி சுழற்றுவதற்காக ரகசியங்களின் பட்டியலை ஏற்கிறது.

Python
from thunderphone import verify_signature
 
ok = verify_signature(
    header,            # the X-ThunderPhone-Signature-V2 value
    secret=SECRET,     # or [NEW_SECRET, OLD_SECRET] while rotating
    method=method,     # "POST"
    path=path,         # "/tools/lookup?region=us", exactly as received
    body=raw_body,     # bytes, before any JSON parsing
    tolerance=300,     # optional; seconds
)
Node.js
import { verifySignature } from "@thunderphone/sdk";
 
const ok = verifySignature({
  header,               // the X-ThunderPhone-Signature-V2 value
  secret: SECRET,       // or [NEW_SECRET, OLD_SECRET] while rotating
  method,               // "POST"
  path,                 // "/tools/lookup?region=us", exactly as received
  body: rawBody,        // Buffer or string, before any JSON parsing
  toleranceSeconds: 300, // optional
});

SDK இல்லாமல்

Python
import hashlib
import hmac
import time
 
TOLERANCE_SECONDS = 300
 
 
def verify_v2(header: str, secret: str, method: str, path: str, body: bytes) -> bool:
    """path is the path plus ?query exactly as received; body is the raw body."""
    timestamp, signatures = None, []
    for item in (header or "").split(","):
        key, _, value = item.strip().partition("=")
        if key == "t" and value.isdigit() and len(value) <= 15:
            timestamp = int(value)
        elif key == "v1":
            signatures.append(value)
    if timestamp is None or abs(time.time() - timestamp) > TOLERANCE_SECONDS:
        return False
    signed = f"{timestamp}\n{method.upper()}\n{path}\n".encode() + body
    expected = hmac.new(secret.encode(), signed, hashlib.sha256).hexdigest()
    return any(hmac.compare_digest(expected.encode(), s.encode()) for s in signatures)
Node.js
import crypto from "node:crypto";
 
const TOLERANCE_SECONDS = 300;
 
// path is the path plus ?query exactly as received; body is the raw Buffer.
export function verifyV2(header, secret, method, path, body) {
  let timestamp;
  const signatures = [];
  for (const item of (header || "").split(",")) {
    const [key, value = ""] = item.trim().split("=", 2);
    if (key === "t" && /^\d+$/.test(value)) timestamp = Number(value);
    else if (key === "v1") signatures.push(value);
  }
  if (timestamp === undefined) return false;
  if (Math.abs(Date.now() / 1000 - timestamp) > TOLERANCE_SECONDS) return false;
  const expected = Buffer.from(
    crypto
      .createHmac("sha256", secret)
      .update(`${timestamp}\n${method.toUpperCase()}\n${path}\n`)
      .update(body)
      .digest("hex"),
  );
  return signatures.some((sig) => {
    const candidate = Buffer.from(sig);
    return (
      candidate.length === expected.length &&
      crypto.timingSafeEqual(candidate, expected)
    );
  });
}

ஃப்ரேம்வொர்க் இணைப்பு

ஒவ்வொரு எடுத்துக்காட்டும் மூல பாதை, வினவல் மற்றும் மூல body-ஐப் படித்து, பின்னர் SDK உதவியாளரை அழைக்கிறது.

FastAPI
import json
 
from fastapi import FastAPI, HTTPException, Request
from thunderphone import verify_signature
 
app = FastAPI()
 
 
def raw_path_and_query(request: Request) -> str:
    path = (request.scope.get("raw_path") or request.url.path.encode()).decode("latin-1")
    query = request.scope.get("query_string", b"").decode("latin-1")
    return f"{path}?{query}" if query else path
 
 
@app.post("/thunderphone-webhook")
async def hook(request: Request):
    body = await request.body()  # raw bytes, NOT request.json()
    if not verify_signature(
        request.headers.get("X-ThunderPhone-Signature-V2"),
        secret=SECRET,
        method=request.method,
        path=raw_path_and_query(request),
        body=body,
    ):
        raise HTTPException(status_code=401)
    event = json.loads(body)
    # … dispatch on event["type"] …
    return {"ok": True}
Express
import express from "express";
import { verifySignature } from "@thunderphone/sdk";
 
const app = express();
 
app.post(
  "/thunderphone-webhook",
  // IMPORTANT: parse as raw; do NOT use express.json() here.
  express.raw({ type: "application/json" }),
  (req, res) => {
    const ok = verifySignature({
      header: req.header("X-ThunderPhone-Signature-V2"),
      secret: process.env.WEBHOOK_SECRET,
      method: req.method,
      path: req.originalUrl, // path and query as received
      body: req.body,
    });
    if (!ok) return res.sendStatus(401);
    const event = JSON.parse(req.body.toString("utf8"));
    // … dispatch on event.type …
    res.sendStatus(204);
  },
);
Django
import json
 
from django.http import HttpResponseForbidden, JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from thunderphone import verify_signature
 
 
@csrf_exempt
@require_POST
def hook(request):
    if not verify_signature(
        request.headers.get("X-ThunderPhone-Signature-V2"),
        secret=SECRET,
        method=request.method,
        path=request.get_full_path(),
        body=request.body,  # raw bytes
    ):
        return HttpResponseForbidden("invalid signature")
    event = json.loads(request.body)
    # … dispatch on event["type"] …
    return JsonResponse({"ok": True})

req.originalUrl (Express) மற்றும் ASGI-யின் raw_path, query_string (FastAPI) ஆகியவை பெறப்பட்டபடியே இலக்காக இருக்கும். Django-வின் get_full_path() மற்றும் Flask-இன் request.path முதலில் பாதையை டிகோடு செய்கின்றன; இது சாதாரண பாதைகளுக்கு அதே சரத்தை வழங்கும். உங்கள் எண்ட்பாயிண்ட் பாதையில் %2F, ; அல்லது = போன்ற சதவீத-என்கோடு செய்யப்பட்ட அல்லது ஒதுக்கப்பட்ட எழுத்துகள் இருந்தால், அதற்குப் பதிலாக உங்கள் சர்வர் வழங்கும் மூல இலக்கைப் படியுங்கள் (எடுத்துக்காட்டாக, Gunicorn-இல் request.META["RAW_URI"]).

எந்த ரகசியம்?

இரண்டு header-களுக்கும் ஒரே secret கையொப்பமிடுகிறது.

மூலம்ரகசியம்
வெப்ஹுக் எண்ட்பாயிண்ட் (/v1/developer/webhook-endpoints)உருவாக்கும்போது ஒருமுறை வழங்கப்படும் எண்ட்பாயிண்ட்-ஒன்றுக்கான secret (48 ஹெக்ஸ் எழுத்துகள்)
பழைய ஒற்றை-URL வெப்ஹுக்GET /v1/webhook-இல் வழங்கப்படும் நிறுவனம்-ஒன்றுக்கான secret
கருவி-எண்ட்பாயிண்ட் அழைப்பு (உங்கள் endpoint.url-க்கு நேரடி அழைப்பு)நிறுவன-நிலை வெப்ஹுக் ரகசியம் (பழைய ஒற்றை-URL வெப்ஹுக்கில் உள்ளதே) — எண்ட்பாயிண்ட்-ஒன்றுக்கான ரகசியம் அல்ல

ரகசியத்தை உங்கள் ரகசிய மேலாளர் அல்லது env மாறியில் சேமியுங்கள் — அதை ஒருபோதும் கமிட் செய்யாதீர்கள்.

டூல் அழைப்புகளைச் சரிபார்த்தல்

ஏஜென்ட் உங்கள் செயல்பாட்டுக் கருவிகளில் ஒன்றை நேரடியாக அழைக்கும்போது (அந்தக் கருவிக்கு endpoint உள்ளது), கோரிக்கை உங்கள் கட்டமைக்கப்பட்ட endpoint.headers உடன் இந்த ThunderPhone தலைப்புகளையும் கொண்டிருக்கும்:

  • X-ThunderPhone-Call-ID — நேரடி அழைப்பின் எண் அடையாளம்.
  • X-ThunderPhone-Signature-V2 — உங்கள் நிறுவன-நிலை வெப்ஹுக் ரகசியம் மூலம் விசையிடப்பட்ட, மேலே உள்ள நேரமுத்திரையிடப்பட்ட கையொப்பம்.
  • X-ThunderPhone-Signature — அதே விசையுடன், உடலை மட்டும் கொண்ட மரபுவழி கையொப்பம்.

தொலைபேசி அழைப்புகள் X-ThunderPhone-From-Number, X-ThunderPhone-To-Number மற்றும் X-ThunderPhone-Call-Direction (விவரங்கள்) ஆகியவற்றையும் கொண்டிருக்கும். ஒவ்வொரு ஹெடரையும் போலவே, இவையும் எந்தக் கையொப்பத்தாலும் உள்ளடக்கப்படுவதில்லை.

உங்கள் நிறுவனம் மரபு வெப்ஹூக்கை ஒருபோதும் கட்டமைக்கவில்லை என்றாலும், ஒவ்வொரு கருவி கோரிக்கைக்கும் கையொப்பமிடப்படும்: ThunderPhone நிறுவன ரகசியத்தைத் தானாக உருவாக்கும். அதை GET /v1/webhook இலிருந்து பெறுங்கள்.

வெப்ஹூக்குகளிலிருந்து ஒரு விஷயம் வேறுபடுகிறது: GET / DELETE கருவிகளுக்கு உடல் இல்லை. அளவுருக்கள் வினவல் அளவுருக்களாக அனுப்பப்படுகின்றன. V2 கையொப்பம் அவற்றை பாதை மற்றும் வினவல் மூலம் உள்ளடக்கும்; உடல் புலம் வெற்றாக இருக்கும். மூல வினவல் சரத்தைக் கொண்டு சரிபார்க்கவும்: அளவுருக்களைப் பாகுபடுத்தி புதிய வினவல் சரத்தை உருவாக்குவது அவற்றின் வரிசை அல்லது குறியீட்டாக்கத்தை மாற்றக்கூடும். மரபு ஹெடர் வெற்று பைட் சரத்திற்கு கையொப்பமிடுகிறது.

@app.api_route("/tools/search-appointments", methods=["GET", "POST"])
async def tool(request: Request):
    body = await request.body()  # b"" for GET/DELETE tools
    if not verify_signature(
        request.headers.get("X-ThunderPhone-Signature-V2"),
        secret=ORG_WEBHOOK_SECRET,
        method=request.method,
        path=raw_path_and_query(request),
        body=body,
    ):
        raise HTTPException(status_code=401)
    call_id = request.headers.get("X-ThunderPhone-Call-ID", "")
    args = json.loads(body) if body else dict(request.query_params)
    ...

Express-இல், ஒரு உடல் பகுப்பாய்வி GET கோரிக்கையில் req.body ஐ வெற்று பொருளாக விடும்; எனவே Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0) ஐ அனுப்பவும்.

வெப்ஹூக்-பயன்முறை டூல் அனுப்புதல் (endpoint இல்லாத டூல்கள், உங்கள் நிறுவன வெப்ஹூக்கிற்கு telephony.tool / web.tool ஆக அனுப்பப்படுபவை) ஒரு சாதாரண கையொப்பமிடப்பட்ட வெப்ஹூக் ஆகும் — மேலே உள்ள நிலையான முறையே பொருந்தும். இரண்டு கோரிக்கை வடிவங்களுக்கும் செயல்பாட்டு டூல்களை பார்க்கவும்.

பழைய கையொப்பம்: X-ThunderPhone-Signature

அசல் ஹெடர் என்பது அதே ரகசியத்தைப் பயன்படுத்தி raw body-க்கு மட்டும் உருவாக்கப்பட்ட ஹெக்ஸ் HMAC-SHA256 ஆகும். இதில் நேரமுத்திரை இல்லை; எனவே ஒரு கையொப்பமிடப்பட்ட கோரிக்கையைப் பிடிக்கும் எவரும் அதை மீண்டும் அனுப்பலாம். ஒருங்கிணைப்புகள் V2-க்கு மாறிக்கொண்டிருக்கும்போதும் இது ஒவ்வொரு கோரிக்கையிலும் அனுப்பப்படுகிறது.

  1. raw கோரிக்கை body-ஐப் படிக்கவும் — நாங்கள் உங்களுக்கு அனுப்பிய துல்லியமான பைட்டுகள்.
  2. hmac_sha256(secret, body).hexdigest()-ஐக் கணக்கிடவும்.
  3. X-ThunderPhone-Signature-உடன் நிலையான நேரத்தில் ஒப்பிடவும்.

நாங்கள் அனுப்பும் துல்லியமான பைட்டுகளுக்கே கையொப்பமிடுகிறோம். அந்தப் பைட்டுகள் payload-இன் நியமமான JSON வரிசைப்படுத்தலும் ஆகும் — விசைகள் அகரவரிசையில் வரிசைப்படுத்தப்பட்டவை, சுருக்கமான பிரிப்பான்கள் (இடைவெளிகளில்லாத , மற்றும் :), UTF-8. உங்கள் framework பிரித்தறியப்பட்ட JSON-ஐ மட்டுமே வழங்கினால், அதை நியமமாக மீண்டும் வரிசைப்படுத்தி அதற்கான HMAC-ஐக் கணக்கிடவும்:

# Equivalent to hashing the raw body:
import json
canonical = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")

raw body-ஐப் பயன்படுத்துவது சிறந்தது — அது ஒரு படி குறைவு; மேலும் சில மொழிகளில் JSON எண்களை மீண்டும் மாற்றும்போது ஏற்படும் நுணுக்கங்களிலிருந்து பாதுகாப்பானது. V2-இன் body புலத்திற்கும் இதுவே பொருந்தும்.

Python
import hashlib
import hmac
 
 
def verify(body: bytes, signature: str, secret: str) -> bool:
    """Constant-time HMAC-SHA256 verification."""
    expected = hmac.new(
        secret.encode("utf-8"),
        body,
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, signature or "")
Node.js
import crypto from "node:crypto";
 
export function verify(body, signature, secret) {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  if (!signature || expected.length !== signature.length) return false;
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature),
  );
}
Go
package webhook
 
import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
)
 
func Verify(body []byte, signature, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(body)
    expected := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(expected), []byte(signature))
}
Ruby
require "openssl"
 
def verify(body, signature, secret)
  expected = OpenSSL::HMAC.hexdigest("SHA256", secret, body)
  Rack::Utils.secure_compare(expected, signature.to_s)
end

பொதுவான சிக்கல்கள்

கடிகார நேரச் சாய்வு

5-நிமிடச் சாளரம் உங்கள் சர்வரின் கடிகாரத்தை அடிப்படையாகக் கொண்டு அளவிடப்படுகிறது. அதை NTP உடன் ஒத்திசைவாக வைத்திருங்கள்; 5 நிமிடங்களுக்கு மேல் தவறான கடிகாரம் ஒவ்வொரு கோரிக்கையையும் நிராகரிக்கும்.

ஒரு ப்ராக்ஸி பாதையை மாற்றி எழுதுகிறது

கையொப்பமிடப்பட்ட பாதை என்பது நாங்கள் கோரியதுதான்: நீங்கள் ThunderPhone-இல் கட்டமைத்த URL-இன் பாதை. உங்கள் பயன்பாடு கோரிக்கையைப் பார்ப்பதற்கு முன் ஒரு ரிவர்ஸ் ப்ராக்ஸி அல்லது API கேட்வே முன்னொட்டைப் நீக்கினாலோ சேர்த்தாலோ, சரிபார்ப்பதற்கு முன் நாங்கள் அனுப்பிய பாதையை மீண்டும் உருவாக்குங்கள் (எடுத்துக்காட்டாக, முன்னொட்டை மீண்டும் சேர்க்கவும்).

இயல்புநிலை வடிவமைப்புடன் மீண்டும் சீரியலைஸ் செய்வது

உடலைப் பகுத்து, உங்கள் JSON நூலகத்தின் இயல்புநிலை அமைப்புகளுடன் (, / :-க்குப் பின் இடைவெளிகள், செருகல் வரிசையிலான விசைகள்) மீண்டும் சீரியலைஸ் செய்வது வேறுபட்ட பைட்களை உருவாக்கி HMAC-ஐ பாதிக்கும். மூல உடலைச் சரிபார்க்கவும் — அல்லது நீங்கள் மீண்டும் சீரியலைஸ் செய்ய வேண்டியிருந்தால், எங்கள் நியம வடிவத்துடன் துல்லியமாகப் பொருந்தச் செய்யுங்கள்: வரிசைப்படுத்தப்பட்ட விசைகள், சுருக்கமான பிரிப்பான்கள், UTF-8.

Framework தானாக JSON-ஐப் பாகுபடுத்துகிறது

Express-இன் express.json() middleware body stream-ஐப் பயன்படுத்திவிடும்; இதனால் மூல byte-களை இழப்பீர்கள். webhook route-க்கு மட்டும் express.raw()-ஐப் பயன்படுத்தவும், அல்லது pre-middleware-இல் மூல body-ஐ buffer செய்யவும். NestJS / Koa-விற்கும் இதுவே பொருந்தும் — அவற்றின் "raw body" ஆவணங்களைப் பார்க்கவும்.

நேர-பாதுகாப்பற்ற ஒப்பீடு

JS-இல் expected === signature அல்லது Python-இல் expected == signature நேரத்தைப் பொறுத்து மாறும் ஒப்பீடுகள். முறையே crypto.timingSafeEqual அல்லது hmac.compare_digest-ஐப் பயன்படுத்தவும். செயல்திறன் வேறுபாடு இல்லை.

கருவி எண்ட்பாயிண்ட்களுக்கான தவறான ரகசியம்

நேரடி கருவி-எண்ட்பாயிண்ட் அழைப்புகள் நிறுவன-நிலை வெப்ஹுக் ரகசியம் (GET /v1/webhook) மூலம் கையொப்பமிடப்படுகின்றன — /v1/developer/webhook-endpoints-இலுள்ள ஒவ்வொரு எண்ட்பாயிண்டுக்கான ரகசியம் மூலமாக அல்ல. அதே உதவி செயல்பாட்டை மீண்டும் பயன்படுத்துங்கள், ஆனால் கருவி ரூட்களில் அதற்கு நிறுவன ரகசியத்தையே வழங்குவதை உறுதிசெய்யுங்கள்.

GET/DELETE கருவிகளில் வினவல் சரங்கள்

V2, அனுப்பப்பட்டபடியே வினவல் சரத்தில் கையொப்பமிடுகிறது. பழைய ஹெடர் காலியான உடலில் கையொப்பமிடும்; வினவல் சரத்தில் ஒருபோதும் கையொப்பமிடாது, எனவே பழைய ஹெடருக்காக URL-ஐ ஹாஷ் செய்வது ஒருபோதும் பொருந்தாது.

சாளரத்திற்குள் நகல்கள்

நேரமுத்திரை 5 நிமிடங்களை விடப் பழைய மீள்அனுப்பல்களைத் தடுக்கிறது; அந்தச் சாளரத்திற்குள் உள்ள இரண்டாவது நகலை அல்ல. எண்ட்பாயிண்ட் விநியோகங்கள் குறைந்தது-ஒருமுறை முறையைப் பின்பற்றுகின்றன, எனவே அதே நிகழ்வின் மறுமுயற்சியும் வரலாம்; உறையின் event_id அடிப்படையில் நகல்களை நீக்குங்கள்.

பொருந்தாதபோது 401-ஐ வழங்காமை

சரிபார்ப்பு தோல்வியடைந்தபோது 200-ஐ வழங்குவது handler-ஐ replay இலக்காக மாற்றுகிறது. சரிபார்ப்பு தோல்வியடைந்தால் எப்போதும் 2xx அல்லாத பதிலை வழங்கவும்.


அடுத்த படிகள்