Amankan Backend Node.js Anda: Validasi HMAC untuk Webhook Didit (ID)

Lindungi Integritas DataValidasi tanda tangan HMAC sangat penting untuk memverifikasi keaslian dan integritas payload webhook, melindungi backend Anda dari permintaan yang diubah atau penipuan.

Cegah Serangan ReplayValidasi stempel waktu, bersama dengan tanda tangan HMAC, menambahkan lapisan pertahanan penting terhadap serangan replay, memastikan bahwa hanya notifikasi baru yang diproses.

Integrasi Tanpa HambatanPendekatan Didit yang mengutamakan pengembang menyediakan dokumentasi dan alat yang jelas, membuat integrasi pemrosesan webhook yang aman ke dalam aplikasi Node.js Anda menjadi mudah dan efisien.

Infrastruktur Aman DiditPlatform Didit dibangun dengan mempertimbangkan keamanan, menawarkan notifikasi KYC real-time melalui webhook dengan verifikasi tanda tangan HMAC yang kuat, memungkinkan Anda membangun solusi identitas yang tepercaya dan sesuai.

Kebutuhan Kritis akan Keamanan Webhook

Webhook adalah alat yang ampuh untuk komunikasi real-time antara layanan, memungkinkan pembaruan instan dan arsitektur berbasis peristiwa. Dalam konteks verifikasi identitas, Didit menggunakan webhook untuk memberi tahu backend Anda tentang selesainya sesi verifikasi, hasil penyaringan AML, atau peristiwa terkait identitas penting lainnya. Meskipun sangat efisien, webhook juga menimbulkan tantangan keamanan. Tanpa validasi yang tepat, pelaku jahat dapat mengirim payload webhook palsu atau yang diubah, yang menyebabkan pemrosesan data yang salah, tindakan tidak sah, atau bahkan kompromi sistem.

Di sinilah validasi tanda tangan HMAC (Hash-based Message Authentication Code) menjadi sangat diperlukan. HMAC menyediakan mekanisme kriptografi untuk memverifikasi keaslian dan integritas pesan. Dengan menggunakan kunci rahasia bersama, backend Anda dapat memastikan bahwa payload webhook berasal dari Didit dan belum dirusak dalam perjalanan. Untuk sistem apa pun yang menangani data identitas sensitif, seperti yang diproses oleh layanan Verifikasi ID, Penyaringan AML, atau Bukti Alamat Didit, tingkat keamanan ini bukan hanya praktik terbaik—ini adalah suatu keharusan.

Memahami Validasi Tanda Tangan HMAC

Validasi HMAC bekerja dengan menghasilkan tanda tangan unik untuk setiap payload webhook menggunakan kunci rahasia yang hanya diketahui oleh Didit dan aplikasi Anda. Ketika backend Node.js Anda menerima webhook, ia melakukan perhitungan tanda tangan yang sama menggunakan salinan kunci rahasianya. Jika tanda tangan yang dihitung cocok dengan tanda tangan yang disediakan di header webhook, Anda dapat yakin bahwa payload tersebut asli dan tidak dirusak.

Webhook Didit menyertakan header X-Signature yang berisi tanda tangan HMAC-SHA256 dan header X-Timestamp. Stempel waktu sangat penting untuk mencegah serangan replay. Serangan replay terjadi ketika penyerang mencegat webhook yang sah dan mengirim ulang nanti. Dengan memvalidasi bahwa stempel waktu masih baru (misalnya, dalam jendela 5 menit), Anda dapat membuang permintaan lama yang berpotensi diputar ulang.

Menerapkan Validasi HMAC di Node.js

Mari kita bahas langkah-langkah untuk menerapkan validasi tanda tangan HMAC untuk webhook Didit di aplikasi Node.js Express. Anda memerlukan akses ke kunci rahasia webhook Anda, yang dapat ditemukan di Konsol Bisnis Didit Anda atau diambil melalui API manajemen.

1. Konfigurasi Titik Akhir Webhook Anda

Pertama, siapkan titik akhir Express yang dapat menerima permintaan POST. Sangat penting untuk mengakses isi permintaan mentah sebelum middleware penguraian JSON apa pun, karena tanda tangan dihitung dari payload mentah.

const express = require('express');
const crypto = require('crypto');
const bodyParser = require('body-parser');

const app = express();
const DIDIT_WEBHOOK_SECRET = process.env.DIDIT_WEBHOOK_SECRET; // Simpan dengan aman!

// Middleware untuk mendapatkan body mentah
app.use(bodyParser.json({ verify: (req, res, buf) => {
  req.rawBody = buf.toString();
}}));

app.post('/api/webhooks/didit', (req, res) => {
  // Logika pemrosesan webhook akan ditempatkan di sini
  res.status(200).send('Webhook diterima');
});

app.listen(3000, () => console.log('Server berjalan di port 3000'));

2. Verifikasi Tanda Tangan HMAC

Di dalam handler webhook Anda, Anda akan mengekstrak stempel waktu dan tanda tangan dari header, merekonstruksi payload yang ditandatangani, dan membandingkan tanda tangan yang Anda hitung dengan yang disediakan oleh Didit.

app.post('/api/webhooks/didit', (req, res) => {
  const signatureHeader = req.headers['x-signature'];
  const timestampHeader = req.headers['x-timestamp'];
  const rawBody = req.rawBody;

  if (!signatureHeader || !timestampHeader || !rawBody) {
    return res.status(400).send('Header atau body webhook hilang.');
  }

  const [algorithm, diditSignature] = signatureHeader.split('=');

  if (algorithm !== 'sha256') {
    return res.status(400).send('Algoritma tanda tangan tidak didukung.');
  }

  // Rekonstruksi string payload yang ditandatangani
  const signedPayload = `${timestampHeader}.${rawBody}`;

  // Hitung tanda tangan Anda sendiri
  const expectedSignature = crypto
    .createHmac('sha256', DIDIT_WEBHOOK_SECRET)
    .update(signedPayload)
    .digest('hex');

  // Bandingkan tanda tangan dengan aman
  const signatureMatches = crypto.timingSafeEqual(
    Buffer.from(diditSignature, 'utf8'),
    Buffer.from(expectedSignature, 'utf8')
  );

  if (!signatureMatches) {
    console.warn('Tanda tangan webhook tidak cocok!');
    return res.status(401).send('Tanda tangan tidak valid.');
  }

  // Tanda tangan valid, sekarang periksa stempel waktu
  // ... (validasi stempel waktu di langkah selanjutnya)

  // Proses event
  console.log('Webhook berhasil divalidasi:', req.body);
  res.status(200).send('Webhook diterima dan diproses.');
});

3. Validasi Stempel Waktu

Setelah memverifikasi tanda tangan, pastikan webhook bukan replay. Praktik umum adalah mengizinkan jendela toleransi kecil (misalnya, 5 menit) untuk penundaan jaringan.

// ... (di dalam handler webhook, setelah validasi tanda tangan)

  const fiveMinutesAgo = Date.now() / 1000 - (5 * 60); // 5 menit dalam detik
  const eventTimestamp = parseInt(timestampHeader, 10);

  if (isNaN(eventTimestamp) || eventTimestamp < fiveMinutesAgo) {
    console.warn('Stempel waktu webhook terlalu lama atau tidak valid!');
    return res.status(401).send('Stempel waktu tidak valid atau lama.');
  }

  // Sekarang Anda dapat dengan aman mengurai dan memproses body JSON
  try {
    const event = JSON.parse(rawBody);
    console.log('Event Didit diproses:', event);
    // Contoh: Perbarui status pengguna berdasarkan event.database_validation.status

    // Struktur Laporan Validasi Database Didit:
    // const validationStatus = event.database_validation.status;
    // const matchType = event.database_validation.match_type;
    // console.log(`Status Validasi: ${validationStatus}, Tipe Cocok: ${matchType}`);

    res.status(200).send('Webhook diterima dan diproses.');
  } catch (error) {
    console.error('Kesalahan dalam mengurai body webhook:', error);
    res.status(400).send('Body JSON tidak valid.');
  }
});

Praktik Terbaik untuk Penanganan Webhook

• Simpan Rahasia dengan Aman: Jangan pernah mengkodekan kunci rahasia webhook Anda secara langsung. Gunakan variabel lingkungan atau layanan manajemen rahasia yang aman.
• Idempoten: Rancang handler webhook Anda agar idempoten. Ini berarti bahwa memproses webhook yang sama beberapa kali (karena percobaan ulang, misalnya) harus memiliki efek yang sama dengan memprosesnya sekali.
• Pemrosesan Asinkron: Untuk tugas yang berjalan lama, akui webhook segera dengan respons 200 OK dan kemudian proses payload secara asinkron menggunakan antrean pesan. Ini mencegah waktu habis dan memastikan Didit tidak terus mencoba ulang webhook.
• Pencatatan dan Pemantauan: Terapkan pencatatan yang kuat untuk semua webhook yang diterima, termasuk kegagalan validasi. Pantau titik akhir webhook Anda untuk aktivitas yang tidak biasa atau tingkat kesalahan yang tinggi.
• Penanganan Kesalahan: Kembalikan kode status HTTP yang sesuai (misalnya, 400 untuk permintaan buruk, 401 untuk tidak sah, 500 untuk kesalahan server) untuk membantu Didit memahami apakah percobaan ulang diperlukan.

Bagaimana Didit Membantu

Didit dirancang untuk menjadi platform identitas yang mengutamakan pengembang dan berbasis AI, membuat integrasi yang aman seperti pemrosesan webhook menjadi mudah dan andal. Arsitektur modular kami berarti Anda dapat dengan mudah memasang pemeriksaan identitas, termasuk Verifikasi ID, Liveness Pasif & Aktif, serta Penyaringan & Pemantauan AML, dan menerima pembaruan real-time melalui webhook yang aman. Didit menyediakan dokumentasi dan contoh yang jelas untuk mengintegrasikan webhook, memastikan Anda dapat dengan cepat menyiapkan saluran komunikasi yang kuat dan aman.

Kami percaya dalam membuat verifikasi identitas dapat diakses dan kuat. Itulah mengapa kami menawarkan KYC Inti Gratis, model bayar-per-verifikasi berhasil, dan sama sekali tidak ada biaya pengaturan. Dengan memanfaatkan platform Didit, Anda mendapatkan akses ke solusi global yang skalabel yang mengotomatiskan kepercayaan dan mengatur risiko, sambil mempertahankan standar keamanan tertinggi, termasuk validasi tanda tangan HMAC untuk notifikasi real-time.

Siap untuk Memulai?

Siap melihat Didit beraksi? Dapatkan demo gratis hari ini.

Mulai verifikasi identitas secara gratis dengan tingkat gratis Didit.