Webhooks

const crypto = require('crypto');

// The signature as "X-Teal-Signature" header
const receivedTealSignature = '...'; 
const client_secret = 'my little secret';
const requestBody = '...'; // Your request body here

// Make sure to use the raw requestBody when validating the signature.
var signature = crypto
  .createHmac('sha512', client_secret)
  .update(requestBody)
  .digest('hex');

if (receivedTealSignature === signature) {
    console.log('Signature is valid');
} else {
    console.log('Signature is invalid');
}

import hmac
import hashlib

receivedTealSignature = '...'  # The signature as "X-Teal-Signature" header
client_secret = 'my little secret'
requestBody = '...'  # Your request body here

# Make sure to use the raw requestBody when validating the signature.
signature = hmac.new(
  client_secret.encode(),
  msg=requestBody.encode(),
  digestmod=hashlib.sha512
).hexdigest()

if receivedTealSignature == signature:
    print('Signature is valid')
else:
    print('Signature is invalid')

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public class Main {
    public static void main(String[] args) throws Exception {

        // The signature as "X-Teal-Signature" header
        String receivedTealSignature = "...";
        String client_secret = "my little secret";
        String requestBody = "...";  // Your request body here

        // Make sure to use the raw requestBody when validating the signature.
        Mac sha512_HMAC = Mac.getInstance("HmacSHA512");
        SecretKeySpec secret_key = new SecretKeySpec(
          client_secret.getBytes(StandardCharsets.UTF_8),
          "HmacSHA512"
        );
        sha512_HMAC.init(secret_key);

        byte[] hash = sha512_HMAC
        .doFinal(requestBody.getBytes(StandardCharsets.UTF_8));
        StringBuilder sb = new StringBuilder(hash.length * 2);
        for(byte b : hash) {
            sb.append(String.format("%02x", b));
        }
        String signature = sb.toString();

        if (receivedTealSignature.equals(signature)) {
            System.out.println("Signature is valid");
        } else {
            System.out.println("Signature is invalid");
        }
    }
}

import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import java.nio.charset.StandardCharsets
import java.security.InvalidKeyException
import java.security.NoSuchAlgorithmException

 // The signature as "X-Teal-Signature" header
val receivedTealSignature = "..." 
val client_secret = "my little secret"
val requestBody = "..."  // Your request body here

// Make sure to use the raw requestBody when validating the signature.
val sha512_HMAC = Mac.getInstance("HmacSHA512")
val secret_key = SecretKeySpec(
  client_secret.toByteArray(StandardCharsets.UTF_8),
  "HmacSHA512"
)
sha512_HMAC.init(secret_key)

val hash = sha512_HMAC
    .doFinal(requestBody.toByteArray(StandardCharsets.UTF_8))
val signature = hash.joinToString("") { "%02x".format(it) }

if (receivedTealSignature == signature) {
    println("Signature is valid")
} else {
    println("Signature is invalid")
}

const crypto = require('crypto');

// Generate a random 32-byte key
const encryptionKey = crypto.randomBytes(32);

// Encode the key as Base64 for use with the API
const encryptionKeyBase64 = encryptionKey.toString('base64');
console.log('Encryption Key:', encryptionKeyBase64);
// Example output: St/73LZ1xHkwX5TanL7V+YAVczn4acozPf3cFySKQXI=

import os
import base64

# Generate a random 32-byte key
encryption_key = os.urandom(32)

# Encode the key as Base64 for use with the API
encryption_key_base64 = base64.b64encode(encryption_key).decode('utf-8')
print(f"Encryption Key: {encryption_key_base64}")
# Example output: St/73LZ1xHkwX5TanL7V+YAVczn4acozPf3cFySKQXI=

import java.security.SecureRandom;
import java.util.Base64;

public class GenerateEncryptionKey {
    public static void main(String[] args) {
        // Generate a random 32-byte key
        SecureRandom secureRandom = new SecureRandom();
        byte[] key = new byte[32];
        secureRandom.nextBytes(key);
        
        // Encode the key as Base64 for use with the API
        String encryptionKeyBase64 = Base64.getEncoder().encodeToString(key);
        System.out.println("Encryption Key: " + encryptionKeyBase64);
        // Example output: St/73LZ1xHkwX5TanL7V+YAVczn4acozPf3cFySKQXI=
    }
}

import java.security.SecureRandom
import java.util.Base64

// Generate a random 32-byte key
val secureRandom = SecureRandom()
val key = ByteArray(32)
secureRandom.nextBytes(key)

// Encode the key as Base64 for use with the API
val encryptionKeyBase64 = Base64.getEncoder().encodeToString(key)
println("Encryption Key: $encryptionKeyBase64")
// Example output: St/73LZ1xHkwX5TanL7V+YAVczn4acozPf3cFySKQXI=

const crypto = require('crypto');

function decrypt(
    encryptedBase64,
    ivBase64,
    encryptionKeyBase64
) {
    const encryptionKey = Buffer.from(encryptionKeyBase64, 'base64');
    const iv = Buffer.from(ivBase64, 'base64');
    const encryptedBuffer = Buffer.from(encryptedBase64, 'base64');

    // Extract the auth tag (last 16 bytes) and ciphertext
    const authTag = encryptedBuffer.subarray(encryptedBuffer.length - 16);
    const ciphertext = encryptedBuffer.subarray(0, encryptedBuffer.length - 16);

    const decipher = crypto.createDecipheriv('aes-256-gcm', encryptionKey, iv);
    decipher.setAuthTag(authTag);
    let decrypted = decipher.update(ciphertext);
    try {
        const final = decipher.final();
        if (final.length > 0) {
            decrypted = Buffer.concat([decrypted, final]);
        }

        const payload = JSON.parse(decrypted.toString('utf8'));
        console.log('Decrypted payload:', payload);
    } catch (error) {
        console.error('Decryption failed:', error);
    }
}

decrypt(
    webhookRequest.body,
    webhookRequest.headers['x-teal-encryption-iv'],
    yourSecretStorage.base64EncryptionKey
)

import base64
import json
from Crypto.Cipher import AES

def decrypt(
    encrypted_base64: str,
    iv_base64: str,
    encryption_key_base64: str
) -> dict:
    encryption_key = base64.b64decode(encryption_key_base64)
    print(f"Key length: {len(encryption_key)} bytes")
    iv = base64.b64decode(iv_base64)
    print(f"IV length: {len(iv)} bytes")

    encrypted_data = base64.b64decode(encrypted_base64)
    print(f"Encrypted data length: {len(encrypted_data)} bytes")

    auth_tag = encrypted_data[-16:]
    ciphertext = encrypted_data[:-16]
    print(f"Auth tag length: {len(auth_tag)} bytes")
    print(f"Ciphertext length: {len(ciphertext)} bytes")

    cipher = AES.new(encryption_key, AES.MODE_GCM, nonce=iv)

    decrypted_data = cipher.decrypt_and_verify(ciphertext, auth_tag)

    payload = json.loads(decrypted_data.decode('utf-8'))
    print("Decryption successful!")
    print(f"Decrypted payload: {payload}")
    return payload

if __name__ == "__main__":
    decrypt(
        webhookRequest.body,
        webhookRequest.headers["x-teal-encryption-iv"],
        secretStorage.base64Secret
    )

import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class DecryptMessage {

    public static String decryptWebhookPayload(
        String encryptedData,
        String encryptionKey,
        String ivBase64
    ) throws Exception {
        byte[] key = Base64.getDecoder().decode(encryptionKey);
        byte[] iv = Base64.getDecoder().decode(ivBase64);
        byte[] encryptedBytes = Base64.getDecoder().decode(encryptedData);

        SecretKeySpec secretKey = new SecretKeySpec(key, "AES");
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec spec = new GCMParameterSpec(128, iv);

        cipher.init(Cipher.DECRYPT_MODE, secretKey, spec);
        byte[] decryptedBytes = cipher.doFinal(encryptedBytes);

        return new String(decryptedBytes, "UTF-8");
    }

    public static void main(String[] args) {
        try {
            String result = decryptWebhookPayload(
                "nBPqEB4T1g/88q1P2qm7oYH5MYbR/NpCVBCytMZsB7ux4xR+OYPS8Y/Ye8giQb6UplDitbKlFlHPoA6pzMu3CmD2cew4JvluyKiOQBE61OwETwJ++KkvwuB9WxegKnhncWqg6qwn9WkRGtmKpfrxiXrdvj7V4aKSOFkO8ByWYztQp58Ublm3yNPQyQmnzJOR+/4v8OMbVivcAkumRu8PO2EYr2uqfPvNMonXiNE5fnqJieZKFvRnDi+s6TNZpSsCzWPgfDGn+EqiDbjqWw+eWnUYd3BQ75OOJficovrzk1dYkONm5uYTnZYSdiwMzNm7",
                "7/PxZATSzWbQkS8ZjSt0f+bTMt9oQ6jkm0aYFe3NN24=",
                "vdBbe9Tk7aqo1pZi"
            );
            System.out.println("Decrypted payload: " + result);
        } catch (Exception e) {
            System.err.println("Decryption failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import java.util.Base64
import javax.crypto.Cipher
import javax.crypto.spec.GCMParameterSpec
import javax.crypto.spec.SecretKeySpec

fun decryptWebhookPayload(
    encryptedData: String,
    encryptionKey: String,
    ivBase64: String
): String {
    val key = Base64.getDecoder().decode(encryptionKey)
    val iv = Base64.getDecoder().decode(ivBase64)
    val encryptedBytes = Base64.getDecoder().decode(encryptedData)
    val secretKey = SecretKeySpec(key, "AES")
    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
    val spec = GCMParameterSpec(128, iv)
    cipher.init(Cipher.DECRYPT_MODE, secretKey, spec)
    val decryptedBytes = cipher.doFinal(encryptedBytes)
    return String(decryptedBytes, Charsets.UTF_8)
}

fun main() {
    try {
        val result = decryptWebhookPayload(
            "nBPqEB4T1g/88q1P2qm7oYH5MYbR/NpCVBCytMZsB7ux4xR+OYPS8Y/Ye8giQb6UplDitbKlFlHPoA6pzMu3CmD2cew4JvluyKiOQBE61OwETwJ++KkvwuB9WxegKnhncWqg6qwn9WkRGtmKpfrxiXrdvj7V4aKSOFkO8ByWYztQp58Ublm3yNPQyQmnzJOR+/4v8OMbVivcAkumRu8PO2EYr2uqfPvNMonXiNE5fnqJieZKFvRnDi+s6TNZpSsCzWPgfDGn+EqiDbjqWw+eWnUYd3BQ75OOJficovrzk1dYkONm5uYTnZYSdiwMzNm7",
            "7/PxZATSzWbQkS8ZjSt0f+bTMt9oQ6jkm0aYFe3NN24=",
            "vdBbe9Tk7aqo1pZi"
        )
        println("Decrypted payload: $result")
    } catch (e: Exception) {
        println("Decryption failed: ${e.message}")
        e.printStackTrace()
    }
}