Membangun Middleware Webhook Aman untuk Didit dengan AWS Lambda (ID)

Penerimaan Webhook Aman Menerapkan verifikasi tanda tangan HMAC-SHA256 dan validasi stempel waktu sangat penting untuk mengamankan webhook Didit dari perusakan dan serangan replay, memastikan integritas dan keaslian data.

Arsitektur Pemrosesan Asinkron Memanfaatkan AWS Lambda dan SQS memisahkan penerimaan webhook dari pemrosesan, meningkatkan skalabilitas, keandalan, dan memungkinkan logika hilir yang kompleks tanpa memengaruhi respons waktu nyata.

Pembaruan Identitas Real-time Webhook Didit menyediakan notifikasi instan tentang hasil verifikasi identitas, memungkinkan pembaruan segera status pengguna, peringatan penipuan, atau catatan kepatuhan dalam aplikasi Anda.

Pendekatan Developer-First Didit Didit menawarkan arsitektur modular dan API yang bersih, membuatnya mudah untuk mengintegrasikan hasil verifikasi identitas waktu nyata ke dalam sistem Anda, yang semakin ditingkatkan dengan penawaran KYC inti gratis dan tanpa biaya pengaturan.

Pentingnya Penanganan Webhook yang Aman

Dalam lanskap digital yang saling terhubung saat ini, pertukaran data waktu nyata sangat penting, terutama untuk fungsi-fungsi kritis seperti verifikasi identitas. Webhook berfungsi sebagai tulang punggung untuk notifikasi waktu nyata ini, memungkinkan layanan seperti Didit untuk memberi tahu aplikasi Anda secara instan tentang hasil pemeriksaan identitas, hasil penyaringan AML, atau status deteksi keaktifan. Namun, hanya menerima data tidak cukup; memastikan keaslian, integritas, dan pemrosesan yang tepat waktu sangatlah vital. Titik akhir webhook yang tidak aman dapat menjadi kerentanan yang signifikan, rentan terhadap perusakan data, serangan replay, atau upaya penolakan layanan. Di sinilah middleware API Gateway yang dirancang dengan baik, khususnya untuk webhook Didit, menjadi sangat diperlukan.

Ketika Didit menyelesaikan Verifikasi ID, pemeriksaan Liveness Pasif & Aktif, Pencocokan Wajah 1:1, atau Penyaringan AML, ia mengirim webhook ke titik akhir yang Anda konfigurasikan. Notifikasi ini berisi informasi penting tentang status verifikasi. Tanpa langkah-langkah keamanan yang tepat, aktor jahat dapat memalsukan notifikasi ini, menyebabkan keputusan orientasi pengguna yang salah atau aktivitas penipuan. Misalnya, status 'terverifikasi' yang dipalsukan dapat memberikan akses kepada aktor jahat, sementara status 'gagal' yang dipalsukan dapat menyebabkan pengguna yang sah diblokir. Oleh karena itu, membangun mekanisme penerimaan webhook yang aman dan kuat bukan hanya praktik yang baik; ini adalah keharusan untuk menjaga keamanan dan kepatuhan platform Anda.

Membangun Middleware Kuat dengan AWS Lambda & API Gateway

Untuk menangani webhook Didit secara efektif dan aman, kita dapat memanfaatkan kekuatan AWS Lambda dan API Gateway untuk membuat middleware tanpa server. Arsitektur ini menawarkan skalabilitas, efisiensi biaya, dan ketersediaan tinggi, sangat cocok untuk pemrosesan data berbasis peristiwa. Gagasan intinya adalah agar API Gateway bertindak sebagai titik masuk, meneruskan permintaan ke fungsi Lambda yang bertanggung jawab untuk validasi awal dan pemrosesan yang aman.

Langkah 1: Menyiapkan API Gateway sebagai Titik Masuk

AWS API Gateway Anda akan mengekspos titik akhir publik (misalnya, /api/webhooks/didit) tempat Didit akan mengirim webhook-nya. Sangat penting untuk mengonfigurasi titik akhir ini untuk menerima permintaan POST dan mengintegrasikannya dengan fungsi Lambda Anda. Tidak seperti pengaturan tradisional, API Gateway harus dikonfigurasi untuk meneruskan badan permintaan mentah langsung ke Lambda tanpa penguraian JSON segera. Ini karena verifikasi tanda tangan memerlukan muatan mentah yang persis sama yang dikirim oleh Didit.

Langkah 2: Menerapkan Validasi Aman di AWS Lambda

Fungsi Lambda adalah inti dari middleware Anda. Setelah menerima webhook, ia harus melakukan beberapa langkah validasi kritis sebelum memproses data:

1. Baca Badan Permintaan Mentah: Fungsi Lambda harus mengakses badan permintaan mentah. Ini penting untuk verifikasi tanda tangan HMAC-SHA256.
2. Verifikasi Tanda Tangan HMAC-SHA256: Webhook Didit menyertakan header X-Signature yang berisi tanda tangan HMAC-SHA256. Fungsi Lambda Anda akan menggunakan rahasia webhook Anda (dibagikan antara aplikasi Anda dan Didit) untuk menghitung tanda tangannya sendiri dari badan permintaan mentah. Jika tanda tangan yang dihitung tidak cocok dengan header X-Signature, webhook tidak valid dan harus segera ditolak. Ini melindungi dari perusakan data.
3. Validasi Stempel Waktu: Didit juga menyertakan header X-Timestamp. Fungsi Lambda Anda harus memverifikasi bahwa stempel waktu ini baru, biasanya dalam jendela 5 menit dari waktu saat ini. Ini mencegah serangan replay, di mana penyerang mungkin mengirim ulang peristiwa webhook lama yang sah.
4. Parse Badan JSON: Hanya setelah verifikasi tanda tangan dan stempel waktu yang berhasil, badan mentah harus diurai menjadi objek JSON.

Berikut adalah cuplikan Python konseptual untuk verifikasi tanda tangan dalam Lambda Anda:

import hmac
import hashlib
import time
import json

def verify_webhook_signature(body, headers, secret):
    signature_header = headers.get('X-Signature')
    timestamp_header = headers.get('X-Timestamp')

    if not signature_header or not timestamp_header:
        return False, "Missing signature or timestamp header"

    # Check timestamp for freshness (e.g., within 5 minutes)
    current_time = int(time.time())
    event_timestamp = int(timestamp_header)
    if abs(current_time - event_timestamp) > 300: # 300 seconds = 5 minutes
        return False, "Webhook timestamp too old or too far in future"

    # Reconstruct the signed payload
    signed_payload = f"v1:{timestamp_header}:{body}"

    # Compute HMAC signature
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        signed_payload.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    # Compare signatures in a secure way (constant time comparison)
    if hmac.compare_digest(signature_header, expected_signature):
        return True, "Signature valid"
    else:
        return False, "Signature mismatch"

# In your Lambda handler:
def lambda_handler(event, context):
    body = event['body'] # Raw request body
    headers = event['headers']
    webhook_secret = "YOUR_DIDIT_WEBHOOK_SECRET" # Store securely, e.g., in AWS Secrets Manager

    is_valid, message = verify_webhook_signature(body, headers, webhook_secret)

    if not is_valid:
        print(f"Webhook validation failed: {message}")
        return {
            'statusCode': 403,
            'body': json.dumps({'message': 'Unauthorized'})
        }

    # If valid, parse JSON and proceed with processing
    payload = json.loads(body)
    # ... process payload ...

    return {
        'statusCode': 200,
        'body': json.dumps({'message': 'Webhook received and processed'})
    }

Pemrosesan Asinkron untuk Skalabilitas dan Keandalan

Setelah memvalidasi webhook, praktik terbaik adalah memisahkan proses penerimaan dari logika bisnis yang sebenarnya. Ini berarti fungsi Lambda Anda, setelah validasi, tidak boleh langsung mengeksekusi operasi database yang kompleks atau panggilan API eksternal. Sebaliknya, ia harus mendorong muatan yang divalidasi ke antrean pemrosesan asinkron, seperti AWS SQS (Simple Queue Service).

Arsitektur ini menawarkan beberapa keuntungan:

• Skalabilitas: API Gateway dan Lambda awal Anda dapat menangani volume webhook masuk yang tinggi tanpa terhambat oleh pemrosesan hilir.
• Keandalan: Jika sistem hilir Anda sementara tidak tersedia, pesan tetap berada di antrean, mencegah kehilangan data.
• Pemutusan: Fungsi atau layanan Lambda yang berbeda dapat memproses pesan dari antrean SQS, memungkinkan pengembangan dan penerapan logika bisnis Anda secara modular dan independen (misalnya, memperbarui catatan pengguna, memicu peringatan AML, atau mencatat hasil verifikasi).
• Respons Cepat: Titik akhir webhook awal dapat merespons dengan cepat (misalnya, dengan 200 OK), mencegah Didit mencoba ulang webhook yang tidak perlu.

Ini memastikan bahwa apakah Anda melakukan Verifikasi ID, menggunakan Verifikasi NFC untuk ePaspor, atau memanfaatkan Estimasi Usia untuk kepatuhan, hasilnya diproses secara efisien dan andal.

Bagaimana Didit Membantu

Didit adalah platform identitas yang berorientasi AI, developer-first yang dirancang untuk modularitas dan kemudahan integrasi. Webhook kami adalah contoh utama dari filosofi ini, menyediakan notifikasi real-time dan aman tentang status alur kerja verifikasi identitas Anda. Dengan menawarkan API yang bersih dan dokumentasi yang komprehensif, Didit membuatnya mudah untuk menyiapkan dan mengintegrasikan webhook ini ke dalam middleware kustom Anda, seperti solusi AWS Lambda dan API Gateway yang dijelaskan di atas.

Platform Didit mendukung berbagai primitif verifikasi identitas, termasuk Verifikasi ID (OCR, MRZ, barcode), Liveness Pasif & Aktif, Pencocokan Wajah 1:1 & Pencarian Wajah, Penyaringan & Pemantauan AML, Bukti Alamat, Estimasi Usia, Verifikasi Telepon & Email, dan Verifikasi NFC. Hasil dari setiap pemeriksaan ini dapat dikirim melalui webhook aman kami, memungkinkan Anda membangun sistem yang sangat responsif dan otomatis. Selain itu, Didit menawarkan KYC Inti Gratis, arsitektur modular, dan tanpa biaya pengaturan, menjadikannya pilihan yang mudah diakses dan kuat untuk bisnis dari semua ukuran yang ingin mengotomatiskan kepercayaan dan mengatur risiko.

Siap Memulai?

Siap melihat Didit beraksi? Dapatkan demo gratis hari ini.

Mulai verifikasi identitas secara gratis dengan tingkat gratis Didit.