Webhook Payload

const jose = require('node-jose');

async function decryptWebhookPayload(encryptedData, secretKey) {
  try {
    // Create keystore with your secret key
    const keystore = jose.JWK.createKeyStore();
    await keystore.add(secretKey, 'oct');

    // Decrypt JWE
    const result = await jose.JWE.createDecrypt(keystore).decrypt(encryptedData);

    // Parse JSON payload
    const payload = JSON.parse(result.plaintext.toString());

    return payload;
  } catch (error) {
    throw new Error(`Failed to decrypt webhook: ${error.message}`);
  }
}

// Usage
const SECRET_KEY = process.env.MODULUS_SECRET_KEY;
const webhookData = req.body.data;

const payload = await decryptWebhookPayload(webhookData, SECRET_KEY);
console.log('Decrypted payload:', payload);

from jwcrypto import jwe, jwk
import json

def decrypt_webhook_payload(encrypted_data, secret_key):
    try:
        # Create JWK from secret key
        key = jwk.JWK(kty='oct', k=secret_key)

        # Create JWE object and decrypt
        jwe_token = jwe.JWE()
        jwe_token.deserialize(encrypted_data)
        jwe_token.decrypt(key)

        # Parse JSON payload
        payload = json.loads(jwe_token.payload.decode('utf-8'))

        return payload
    except Exception as e:
        raise Exception(f'Failed to decrypt webhook: {str(e)}')

# Usage
SECRET_KEY = os.getenv('MODULUS_SECRET_KEY')
webhook_data = request.json['data']

payload = decrypt_webhook_payload(webhook_data, SECRET_KEY)
print(f'Decrypted payload: {payload}')

<?php
use Jose\Component\Core\JWK;
use Jose\Component\Encryption\JWEDecrypter;
use Jose\Component\Encryption\Serializer\CompactSerializer;
use Jose\Component\Core\AlgorithmManager;
use Jose\Component\Encryption\Algorithm\KeyEncryption\A256KW;
use Jose\Component\Encryption\Algorithm\ContentEncryption\A256CBCHS512;

function decryptWebhookPayload($encryptedData, $secretKey) {
    try {
        // Create JWK from secret key
        $jwk = new JWK([
            'kty' => 'oct',
            'k' => $secretKey
        ]);

        // Setup algorithm managers
        $keyEncryptionAlgorithmManager = new AlgorithmManager([
            new A256KW()
        ]);

        $contentEncryptionAlgorithmManager = new AlgorithmManager([
            new A256CBCHS512()
        ]);

        // Create decrypter
        $jweDecrypter = new JWEDecrypter(
            $keyEncryptionAlgorithmManager,
            $contentEncryptionAlgorithmManager,
            null
        );

        // Deserialize and decrypt
        $serializer = new CompactSerializer();
        $jwe = $serializer->unserialize($encryptedData);
        $jweDecrypter->decryptUsingKey($jwe, $jwk, 0);

        // Parse JSON payload
        $payload = json_decode($jwe->getPayload(), true);

        return $payload;
    } catch (Exception $e) {
        throw new Exception('Failed to decrypt webhook: ' . $e->getMessage());
    }
}

// Usage
$SECRET_KEY = getenv('MODULUS_SECRET_KEY');
$webhookData = $request['data'];

$payload = decryptWebhookPayload($webhookData, $SECRET_KEY);
error_log('Decrypted payload: ' . json_encode($payload));

require 'json/jwt'

def decrypt_webhook_payload(encrypted_data, secret_key)
  begin
    # Decrypt JWE
    jwe = JSON::JWT.decode(encrypted_data, secret_key)

    return jwe
  rescue => e
    raise "Failed to decrypt webhook: #{e.message}"
  end
end

# Usage
SECRET_KEY = ENV['MODULUS_SECRET_KEY']
webhook_data = request.body['data']

payload = decrypt_webhook_payload(webhook_data, SECRET_KEY)
puts "Decrypted payload: #{payload}"

package main

import (
    "encoding/json"
    "fmt"
    "github.com/square/go-jose/v3"
)

func decryptWebhookPayload(encryptedData string, secretKey []byte) (map[string]interface{}, error) {
    // Parse JWE
    object, err := jose.ParseEncrypted(encryptedData)
    if err != nil {
        return nil, fmt.Errorf("failed to parse JWE: %w", err)
    }

    // Decrypt
    plaintext, err := object.Decrypt(secretKey)
    if err != nil {
        return nil, fmt.Errorf("failed to decrypt: %w", err)
    }

    // Parse JSON
    var payload map[string]interface{}
    if err := json.Unmarshal(plaintext, &payload); err != nil {
        return nil, fmt.Errorf("failed to parse JSON: %w", err)
    }

    return payload, nil
}

// Usage
func main() {
    secretKey := []byte(os.Getenv("MODULUS_SECRET_KEY"))
    webhookData := request.Body["data"].(string)

    payload, err := decryptWebhookPayload(webhookData, secretKey)
    if err != nil {
        log.Fatalf("Decryption failed: %v", err)
    }

    fmt.Printf("Decrypted payload: %+v\n", payload)
}

function validateWebhookPayload(payload) {
  const errors = [];

  // Required fields
  if (!payload.action) errors.push('Missing action field');
  if (!payload.referenceNumber) errors.push('Missing referenceNumber field');
  if (typeof payload.amount !== 'number') errors.push('Invalid or missing amount field');
  if (!payload.currency) errors.push('Missing currency field');
  if (!payload.status) errors.push('Missing status field');

  // Valid action values
  const validActions = ['QRPH_SUCCESS', 'QRPH_DECLINED'];
  if (payload.action && !validActions.includes(payload.action)) {
    errors.push(`Invalid action: ${payload.action}`);
  }

  // Valid status values
  const validStatuses = ['SUCCESS', 'FAILED', 'PENDING', 'REQUIRES_ACTION'];
  if (payload.status && !validStatuses.includes(payload.status)) {
    errors.push(`Invalid status: ${payload.status}`);
  }

  // Amount validation
  if (payload.amount <= 0) {
    errors.push('Amount must be positive');
  }

  // Currency validation
  const validCurrencies = ['PHP', 'USD'];
  if (payload.currency && !validCurrencies.includes(payload.currency)) {
    errors.push(`Unsupported currency: ${payload.currency}`);
  }

  if (errors.length > 0) {
    throw new Error(`Payload validation failed: ${errors.join(', ')}`);
  }

  return true;
}

// Usage
try {
  const payload = await decryptWebhookPayload(webhookData, SECRET_KEY);
  validateWebhookPayload(payload);

  // Proceed with processing
  await processWebhook(payload);
} catch (error) {
  console.error('Invalid webhook:', error.message);
  // Log for investigation but still return 200 OK
}

def validate_webhook_payload(payload):
    errors = []

    # Required fields
    if not payload.get('action'):
        errors.append('Missing action field')
    if not payload.get('referenceNumber'):
        errors.append('Missing referenceNumber field')
    if not isinstance(payload.get('amount'), (int, float)):
        errors.append('Invalid or missing amount field')
    if not payload.get('currency'):
        errors.append('Missing currency field')
    if not payload.get('status'):
        errors.append('Missing status field')

    # Valid action values
    valid_actions = ['QRPH_SUCCESS', 'QRPH_DECLINED']
    if payload.get('action') and payload['action'] not in valid_actions:
        errors.append(f"Invalid action: {payload['action']}")

    # Valid status values
    valid_statuses = ['SUCCESS', 'FAILED', 'PENDING', 'REQUIRES_ACTION']
    if payload.get('status') and payload['status'] not in valid_statuses:
        errors.append(f"Invalid status: {payload['status']}")

    # Amount validation
    if payload.get('amount', 0) <= 0:
        errors.append('Amount must be positive')

    # Currency validation
    valid_currencies = ['PHP', 'USD']
    if payload.get('currency') and payload['currency'] not in valid_currencies:
        errors.append(f"Unsupported currency: {payload['currency']}")

    if errors:
        raise ValueError(f"Payload validation failed: {', '.join(errors)}")

    return True

# Usage
try:
    payload = decrypt_webhook_payload(webhook_data, SECRET_KEY)
    validate_webhook_payload(payload)

    # Proceed with processing
    process_webhook(payload)
except ValueError as e:
    print(f'Invalid webhook: {str(e)}')
    # Log for investigation but still return 200 OK