SVIX लाइब्रेरी के साथ वेबहुक को कैसे सत्यापित करें

हमारी आधिकारिक लाइब्रेरी का उपयोग करके सत्यापन

पुस्तकालयों का उपयोग करके सत्यापन

npm install svix  
# Or  
yarn add svix

pip install svix

http = "1.0.0"  
svix = "1.20.0"

go get github.com/svix/svix-webhooks/go

// Gradle: Add this dependency to your project's build file:
implementation "com.svix:svix:0.x.y"  
 
// Maven: Add this dependency to your project's POM:
<dependency>  
 <groupId>com.svix</groupId> 
 <artifactId>svix</artifactId>
 <version>0.x.y</version>
</dependency>

// Gradle: Add this dependency to your project's build file:
implementation "com.svix.kotlin:svix-kotlin:0.x.y"  
 
// Maven: Add this dependency to your project's POM:
<dependency>  
 <groupId>com.svix.kotlin</groupId> 
 <artifactId>svix-kotlin</artifactId>
 <version>0.x.y</version>
</dependency>

gem install svix

composer require svix/svix

dotnet add package Svix

# On macOS install via [Homebrew](https://brew.sh/):
brew install svix/svix/svix  
 
# On Windows install via [Scoop](https://scoop.sh/):
scoop bucket add svix https://github.com/svix/scoop-svix.git  
scoop install svix  
 
# For other platforms, such as linux, checkout the [CLI docs](https://github.com/svix/svix-cli#installation) on Github.

# Install cURL. E.g. on arch linux:  
pacman -S curl

फिर नीचे दिए गए कोड का उपयोग करके वेबहुक सत्यापित करें। पे लोड अनुरोध का कच्चा (स्ट्रिंग) बॉडी है, और हेडर अनुरोध में पारित हेडर हैं।

कच्चे अनुरोध बॉडी का प्रयोग करें

वेबहुक को सत्यापित करते समय आपको कच्चे अनुरोध बॉडी का उपयोग करने की आवश्यकता होती है, क्योंकि क्रिप्टोग्राफिक सिग्नेचर सबसे मामूली बदलावों के प्रति संवेदनशील होता है। आपको उन ढाँचों पर ध्यान देना चाहिए जो अनुरोध को JSON के रूप में पार्स करते हैं और फिर उसे स्ट्रिंगीफाई करते हैं क्योंकि यह भी सिग्नेचर सत्यापन को तोड़ देगा।

विभिन्न ढाँचों के साथ कच्चे अनुरोध बॉडी को प्राप्त करने के तरीके के उदाहरण नीचे दिए गए हैं।

हस्ताक्षर आपको उस स्थान से प्राप्त करना चाहिए जहाँ आपने एंडपॉइंट जोड़ा है, जैसे एप्लिकेशन पोर्टल।

import { Webhook } from "svix";
 
const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
 
// These were all sent from the server
const headers = {
  "svix-id": "msg_p5jXN8AQM9LWM0D4loKWxJek",
  "svix-timestamp": "1614265330",
  "svix-signature": "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=",
};
const payload = '{"test": 2432232314}';
 
const wh = new Webhook(secret);
// Throws on error, returns the verified content on success
wh.verify(payload, headers);

from svix.webhooks import Webhook  
  
secret =  "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"  
  
# These were all sent from the server  
headers =  {  
 "svix-id":  "msg_p5jXN8AQM9LWM0D4loKWxJek", "svix-timestamp":  "1614265330", "svix-signature":  "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=",}  
payload =  '{"test": 2432232314}'  
  
wh = Webhook(secret)  
# Throws on error, returns the verified content on success  
wh.verify(payload, headers)

use  svix::webhooks::Webhook;  
  
let secret =  "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw".to_string();  
  
let  mut headers =  http::HeaderMap::new();  
headers.insert("svix-id",  "msg_p5jXN8AQM9LWM0D4loKWxJek");  
headers.insert("svix-timestamp",  "1614265330");  
headers.insert(  
 "svix-signature", "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=",);  
  
let payload =  b"{\"test\": 2432232314}";  
  
let wh =  Webhook::new(&secret)?;  
wh.verify(&payload,  &headers)?;  
// returns Ok on success, Err otherwise

import  (  
 svix "github.com/svix/svix-webhooks/go")  
  
secret :=  "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"  
  
// These were all sent from the server  
headers := http.Header{}  
headers.Set("svix-id",  "msg_p5jXN8AQM9LWM0D4loKWxJek")  
headers.Set("svix-timestamp",  "1614265330")  
headers.Set("svix-signature",  "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=")  
  
payload :=  []byte(`{"test": 2432232314}`)  
  
wh, err := svix.NewWebhook(secret)  
err := wh.Verify(payload, headers)  
// returns nil on success, error otherwise

import  com.svix.Webhook;  
  
String secret =  "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";  
  
// These were all sent from the server  
HashMap<String,  List<String>> headerMap =  new  HashMap<String,  List<String>>();  
headerMap.put("svix-id",  Arrays.asList("msg_p5jXN8AQM9LWM0D4loKWxJek"));  
headerMap.put("svix-timestamp",  Arrays.asList("1614265330"));  
headerMap.put("svix-signature",  Arrays.asList("v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="));  
HttpHeaders headers =  HttpHeaders.of(headerMap,  BiPredicate<String,  String>)  
  
String payload =  "{\"test\": 2432232314}";  
  
Webhook webhook =  new  Webhook(secret);  
  
webhook.verify(payload, headers)  
// throws WebhookVerificationError exception on failure.

import com.svix.kotlin.Webhook  
  
val secret =  "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";  
  
// These were all sent from the server  
val headersMap =  mapOf(  
 "svix-id"  to  listOf("msg_p5jXN8AQM9LWM0D4loKWxJek"), "svix-timestamp"  to  listOf("1614265330"), "svix-signature"  to  listOf("v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="))  
val headers = HttpHeaders.of(headersMap)  { _, _ ->  true  }  
  
val payload =  "{\"test\": 2432232314}";  
  
val webhook =  Webhook(secret);  
  
webhook.verify(payload, headers)  
// throws WebhookVerificationError exception on failure.

require  'svix'  
  
  
# These were all sent from the server  
headers =  {  
 "svix-id"  =>  "msg_p5jXN8AQM9LWM0D4loKWxJek", "svix-timestamp"  =>  "1614265330", "svix-signature"  =>  "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="}  
payload =  '{"test": 2432232314}'  
  
wh = Svix::Webhook.new("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw")  
# Raises on error, returns the verified content on success  
json = wh.verify(payload, headers)

using Svix;
using System.Net;
 
// These were all sent from the server
var headers = new WebHeaderCollection();
headers.Set("svix-id", "msg_p5jXN8AQM9LWM0D4loKWxJek");
headers.Set("svix-timestamp", "1614265330");
headers.Set("svix-signature", "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=");
var payload = "{\"test\": 2432232314}";
 
var wh = new Webhook("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw/Je4ZJEGP1QFb");
 
// Throws on error
wh.Verify(payload, headers);

// import using composers autoload
require_once('vendor/autoload.php');
// or manually
require_once('/path/to/svix/php/init.php');
 
// These were all sent from the server
$payload = '{"test": 2432232314}';
$header = array(
        'svix-id'  => 'msg_p5jXN8AQM9LWM0D4loKWxJek',
        'svix-timestamp' => '1614265330',
        'svix-signature' => 'v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=',
    );
 
// Throws on error, returns the verified content on success
$wh = new \Svix\Webhook('whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw');
$json = $wh->verify($payload, $header);

export SVIX_AUTH_TOKEN="AUTH_TOKEN"  
svix verify --secret whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw --msg-id msg_p5jXN8AQM9LWM0D4loKWxJek --timestamp 1614265330 --signature v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=  '{"test": 2432232314}'

# No easy way to verify the signature just with cURL.

फ़्रेमवर्क विशिष्ट उदाहरण

यहाँ आपके पसंदीदा फ़्रेमवर्क में उपरोक्त उदाहरणों को कैसे समायोजित करें, इसके उदाहरण दिए गए हैं!

पायथन (Django)

from django.http import HttpResponse
 
from svix.webhooks import Webhook, WebhookVerificationError
 
secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"
 
@csrf_exempt
def webhook_handler(request):
    headers = request.headers
    payload = request.body
 
    try:
        wh = Webhook(secret)
        msg = wh.verify(payload, headers)
    except WebhookVerificationError as e:
        return HttpResponse(status=400)
 
    # Do something with the message...
 
    return HttpResponse(status=204)

पायथन (Flask)

from flask import request
 
from svix.webhooks import Webhook, WebhookVerificationError
 
secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"
 
@app.route('/webhook/')
def webhook_handler():
    headers = request.headers
    payload = request.get_data()
 
    try:
        wh = Webhook(secret)
        msg = wh.verify(payload, headers)
    except WebhookVerificationError as e:
        return ('', 400)
 
    # Do something with the message...
 
    return ('', 204)

पायथन (FastAPI)

from fastapi import Request, Response, status
 
from svix.webhooks import Webhook, WebhookVerificationError
 
secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"
 
@router.post("/webhook/", status_code=status.HTTP_204_NO_CONTENT)
async def webhook_handler(request: Request, response: Response):
    headers = request.headers
    payload = await request.body()
 
    try:
        wh = Webhook(secret)
        msg = wh.verify(payload, headers)
    except WebhookVerificationError as e:
        response.status_code = status.HTTP_400_BAD_REQUEST
        return
 
    # Do something with the message...

Node.js (Next.js)

import { Webhook } from "svix";
import { buffer } from "micro";
 
export const config = {
    api: {
        bodyParser: false,
    },
}
 
const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
 
export default async function handler(req, res) {
    const payload = (await buffer(req)).toString();
    const headers = req.headers;
 
    const wh = new Webhook(secret);
    let msg;
    try {
        msg = wh.verify(payload, headers);
    } catch (err) {
        res.status(400).json({});
    }
 
    // Do something with the message...
 
    res.json({});
}

Node.js (Next.js 13 App Router)

import { Webhook } from "svix";
 
const webhookSecret: string = process.env.WEBHOOK_SECRET || "your-secret";
 
export async function POST(req: Request) {
  const svix_id = req.headers.get("svix-id") ?? "";
  const svix_timestamp = req.headers.get("svix-timestamp") ?? "";
  const svix_signature = req.headers.get("svix-signature") ?? "";
 
  const body = await req.text();
 
  const sivx = new Webhook(webhookSecret);
 
  let msg;
  
  try {
    msg = sivx.verify(body, {
      "svix-id": svix_id,
      "svix-timestamp": svix_timestamp,
      "svix-signature": svix_signature,
    });
  } catch (err) {
    return new Response("Bad Request", { status: 400 });
  }
 
  console.log(msg);
 
  // Rest
 
  return new Response("OK", { status: 200 });
}

Node.js (Netlify Functions)

import { Webhook } from "svix";
 
const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
 
 
export const handler = async ({body, headers}) => {
    const payload = body;
 
    const wh = new Webhook(secret);
    let msg;
    try {
        msg = wh.verify(payload, headers);
    } catch (err) {
        res.status(400).json({});
    }
 
    // Do something with the message...
 
    res.json({});
}

Node.js (Express)

नोट: इस उदाहरण को बड़े कोडबेस में एकीकृत करते समय, आपको यह सुनिश्चित करना होगा कि वेबहुक रूट पर express.json() मिडिलवेयर लागू न करें, क्योंकि पे लोड को किसी भी पूर्व पार्सिंग के बिना wh.verify में पास किया जाना है।

import { Webhook } from "svix";
import bodyParser from "body-parser";
 
const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
 
app.post('/webhook', bodyParser.raw({ type: 'application/json' }), (req, res) => {
    const payload = req.body;
    const headers = req.headers;
 
    const wh = new Webhook(secret);
    let msg;
    try {
        msg = wh.verify(payload, headers);
    } catch (err) {
        res.status(400).json({});
    }
 
    // Do something with the message...
 
    res.json({});
});

Node.js (NestJS)

rawBody ध्वज को सत्य पर सेट करके एप्लिकेशन को इनिशियलाइज़ करें। विवरण के लिए NestJS डॉक्स देखें।

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
 
async function bootstrap() {
  const app = await NestFactory.create(
    AppModule,
    { rawBody: true } // add rawBody flag
  );
  await app.listen(3000);
}
bootstrap();

// webhook.controller.ts
import { Controller, Post, RawBodyRequest, Req } from '@nestjs/common';
import { Request } from 'express';
import { Webhook } from 'svix';
 
@Controller('webhook')
class WebhookController {
  @Post()
  webhook(@Req() request: RawBodyRequest<Request>) {
    const secret = 'whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw';
    const wh = new Webhook(secret);
 
    const payload = request.rawBody.toString('utf8');
    const headers = request.headers;
 
    let msg;
    try {
      msg = wh.verify(payload, headers);
    } catch (err) {
      // handle error
    }
 
    // Do something with the message...
  }
}

गो (मानक lib)

package main
 
import (
    "io"
    "log"
    "net/http"
 
    svix "github.com/svix/svix-webhooks/go"
)
 
const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"
 
func main() {
 
    wh, err := svix.NewWebhook(secret)
    if err != nil {
        log.Fatal(err)
    }
 
    http.HandleFunc("/webhook", func(w http.ResponseWriter, r *http.Request) {
        headers := r.Header
        payload, err := io.ReadAll(r.Body)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            return
        }
 
        err = wh.Verify(payload, headers)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            return
        }
 
        // Do something with the message...
 
        w.WriteHeader(http.StatusNoContent)
 
    })
    http.ListenAndServe(":8080", nil)
}

गो (Gin)

package main
 
import (
    "io"
    "log"
    "net/http"
 
    "github.com/gin-gonic/gin"
    svix "github.com/svix/svix-webhooks/go"
)
 
const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"
 
func main() {
 
    wh, err := svix.NewWebhook(secret)
    if err != nil {
        log.Fatal(err)
    }
 
    r := gin.Default()
    r.POST("/webhook", func(c *gin.Context) {
        headers := c.Request.Header
        payload, err := io.ReadAll(c.Request.Body)
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
 
        err = wh.Verify(payload, headers)
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
 
        // Do something with the message...
 
        c.JSON(200, gin.H{})
    })
    r.Run()
}

रस्ट (एक्सम)

नीचे दिए गए webhook_in रूट को एक्सम राउटर में जोड़ें।

use axum::{body::Bytes, http::StatusCode};
use hyper::HeaderMap;
 
pub const SECRET: &'static str = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
 
pub async fn webhook_in(headers: HeaderMap, body: Bytes) -> StatusCode {
    let wh = svix::webhooks::Webhook::new(SECRET);
    if let Err(_) = wh {
        return StatusCode::INTERNAL_SERVER_ERROR;
    }
 
    if let Err(_) = wh.verify(&body, &headers) {
        return StatusCode::BAD_REQUEST;
    }
 
    // Do something with the message...
 
    StatusCode::NO_CONTENT
}

रूबी (रूबी ऑन रेल्स)

अपनी परियोजना सेट करने के बाद config/routes.rb फ़ाइल में Rails.application.routes.draw ब्लॉक के शीर्ष पर एक मार्ग जोड़ें:

Rails.application.routes.draw do
  post "/webhook", to: "webhook#index"
 
  # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
end

उपरोक्त मार्ग घोषित करता है कि POST /webhook अनुरोध WebhookController की अनुक्रमणिका क्रिया में मैप किए गए हैं।

WebhookController और उसकी अनुक्रमणिका क्रिया बनाने के लिए, हम नियंत्रक जनरेटर ( --skip-routes विकल्प के साथ क्योंकि हमारे पास पहले से ही एक उपयुक्त मार्ग है) चलाएँगे:

bin/rails generate controller Webhook index --skip-routes

रेल्स आपके लिए कई फाइलें बनाएगा:

    create  app/controllers/webhook_controller.rb
    invoke  erb
    create    app/views/webhook
    create    app/views/webhook/index.html.erb
    invoke  test_unit
    create    test/controllers/webhook_controller_test.rb
    invoke  helper
    create    app/helpers/webhook_helper.rb
    invoke    test_unit
    invoke  assets
    invoke    scss
    create      app/assets/stylesheets/webhook.scss

अब हम अपने सत्यापन तर्क को नव निर्मित app/controllers/webhook_controller.rb फ़ाइल में जोड़ सकते हैं:

require  'svix'  
  
class  WebhookController  < ApplicationController  
 protect_from_forgery with:  :null_session  # disables CSRF middleware; required for API endpoints  
 def  index begin payload = request.body.read headers = request.headers wh = Svix::Webhook.new("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw")  
 json = wh.verify(payload, headers)  
 # Do something with the message...  
 head :no_content rescue head :bad_request end endend

PHP (Laravel)

अपनी routes/api.php फ़ाइल में अंतिम उपयोग निर्देश के बाद निम्न जोड़ें:

use Svix\Webhook;
use Svix\Exception\WebhookVerificationException;
 
Route::post('webhook', function(Request $request) {
    $payload = $request->getContent();
    $headers = collect($request->headers->all())->transform(function ($item) {
        return $item[0];
    });
 
    try {
        $wh = new Webhook("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw");
        $json = $wh->verify($payload, $headers);
 
        # Do something with the message...
 
        return response()->noContent();
    } catch (WebhookVerificationException $e) {
        return response(null, 400);
    }
});

सदस्यता सामान्य प्रश्न