Data Encryption and Decryption

Encryption and Decryption Tool

We provide a desktop tool for trying out the specification on this page. It covers query string encryption and decryption, API calls, and webhook reception in one place.

Encryption & Decryption Tool guide

Download, installation, how to use each tab, and troubleshooting.

Encryption Options

Types of Encryption Modules

Query String Encryption

Secure Data Transmission Options

Encryption/Decryption Methods

1. Types of Encryption Modules

There are two types of encryption modules available:

AES-256: Fast and simple block encryption method
GCM-256: Enhanced encryption method with authentication and integrity features

Types of Encryption Keys

API Key: API key assigned to the Project
Custom API Key (secretKey): New secretKey issued from Liveform for use

2. Query String Encryption

Sensitive data sent via URL query strings is encrypted using the AES-256-ECB or GCM-256 encryption method.

Prepare Data in JSON Format

Refer to the link below for each parameter descriptionKey Query String Parameters

{
    "email": "email@email.com",
    "userid": "userid",
    "cf1": "value 1",
    "cf2": "value 2",
    "cf3": "value 3",
    "blacklistCountries": false,
    "approvePeriod": false,
    "rejectPeriod": false,
    "ageLimit": false,
    "rejectDuplicateUser": true,
    "token": "token_id",
    "allowedCountries": "USA,KOR"
}

{
    "email": "email@email.com",
    "userid": "userid",
    "cf1": "value 1",
    "cf2": "value 2",
    "cf3": "value 3",
    "knowledgeField": "birthDate,gender,nationality,name,SSN,name,address,phoneNumber",
    "knowledgePrefill" : "gender=male,nationality=USA,SSN=123-34-0001,address=Washington D.C.,name=Brown James,birthDate=1980-01-01,phoneNumber=+15555551234",
    "blacklistCountries": false,
    "ageLimit": false,
    "rejectDuplicateUser": true,
    "allowedCountries": "USA"
}

Select Encryption Module AES-256/GCM-256 and API Key or secretKey

Once issued, secretKey will not be displayed again. If lost, please reissue and use it.

Perform AES-256/GCM-256 Encryption Using the Provided API Key

Before performing AES-256 encryption, please verify the query string encryption and decryption steps.
If you have received a secretKey, please use the secretKey.

Add Encrypted Data to the URL as the 'encrypted' Query Parameter

https://form.argosidentity.com?pid={project_Id}&encrypted={encrypted_json_text}

Caution: The following query parameters are not encrypted: pid, lang, sid, action.
The pid, lang query strings and the sid, action query strings used on the “Additional Process (Injection)” page do not support encryption.

3. Query String Encryption and Decryption Methods

3-1. Key Generation Process

AES-256 GCM-256

Generate Hashed Key

var crypto = require('crypto');
var hashedKey = crypto.createHash('sha256').update(APIKEY).digest();

const CryptoJS = require('crypto-js');
const hashedKey = CryptoJS.SHA256(APIKEY);

Encryption Example

Below are examples of encrypting data using AES-256

  var crypto = require('crypto');

  /**
  * @param {string} data - Stringified JSON data
  * @param {string} apiKey - Project API key
  * @returns {string} Encrypted data
  *
  * for exact encryption, use formatJSON.
  * example below,
  * const data = {
      userid: "10912301",
      email: "email@email.com"
  * };
  *
  * do not use string direct way, like
  * `{"userid":"10912301","email":"email@email.com"}`
  * which is not same as expected encryption.
  */

  function encrypt(data, apiKey) {
    var hashedKey = crypto.createHash('sha256').update(apiKey).digest();
    var cipher = crypto.createCipheriv('aes-256-ecb', hashedKey, null);
    return cipher.update(data, 'utf8', 'base64') + cipher.final('base64');
  }

const CryptoJS = require('crypto-js');

const encrypt = (data, apiKey) => {
  const hashedKey = CryptoJS.SHA256(apiKey);
  const encrypted = CryptoJS.AES.encrypt(data, hashedKey, {
    mode: CryptoJS.mode.ECB,
  });
  return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
};

  import javax.crypto.Cipher;
  import javax.crypto.spec.SecretKeySpec;
  import java.nio.charset.StandardCharsets;
  import java.security.MessageDigest;
  import java.util.Base64;

  public class Encryption {
      public static String encrypt(String data, String apiKey) throws Exception {
          // Hash the API key using SHA-256
          MessageDigest digest = MessageDigest.getInstance("SHA-256");
          byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
          
          // Ensure the key is 32 bytes long for AES-256 compatibility
          byte[] aesCompatibleKey = new byte[32];
          System.arraycopy(hashedKey, 0, aesCompatibleKey, 0, 32);
          
          // Create the AES key for encryption
          SecretKeySpec secretKey = new SecretKeySpec(hashedKey, "AES");
          
          // Initialize the Cipher in AES/ECB/PKCS5Padding mode
          Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
          cipher.init(Cipher.ENCRYPT_MODE, secretKey);
          
          // Encrypt the data
          byte[] encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
          
          // Return the encrypted result encoded in Base64
          return Base64.getEncoder().encodeToString(encryptedBytes);
      }
  }

GCM Encryption Example

Below are examples of encrypting data using AES-256-GCM

var crypto = require('crypto');

/**
 * @param {string} data - Stringified JSON data
 * @param {string} apiKey - Project API key
 * @returns {string} Encrypted data in hex format (IV + ciphertext + tag)
 *
 * GCM mode provides authenticated encryption and includes IV and authentication tag.
 * Return value is hex string encoded form of 12-byte IV + ciphertext + 16-byte authentication tag.
 */
function encryptGCM(data, apiKey) {
    var hashedKey = crypto.createHash('sha256').update(apiKey).digest();
    var iv = crypto.randomBytes(12);
    var cipher = crypto.createCipheriv('aes-256-gcm', hashedKey, iv);
    
    var encrypted = cipher.update(data, 'utf8');
    encrypted = Buffer.concat([encrypted, cipher.final()]);
    
    var tag = cipher.getAuthTag();
    var result = Buffer.concat([iv, encrypted, tag]);
    
    return result.toString('hex');
}

/**
 * @param {string} encryptedHex - Hex encoded encrypted data
 * @param {string} apiKey - Project API key
 * @returns {string} Decrypted data
 */
function decryptGCM(encryptedHex, apiKey) {
    var hashedKey = crypto.createHash('sha256').update(apiKey).digest();
    var encryptedBuffer = Buffer.from(encryptedHex, 'hex');
    
    var iv = encryptedBuffer.slice(0, 12);
    var tag = encryptedBuffer.slice(-16);
    var encrypted = encryptedBuffer.slice(12, -16);
    
    var decipher = crypto.createDecipheriv('aes-256-gcm', hashedKey, iv);
    decipher.setAuthTag(tag);
    
    var decrypted = decipher.update(encrypted);
    decrypted = Buffer.concat([decrypted, decipher.final()]);
    
    return decrypted.toString('utf8');
}

const CryptoJS = require('crypto-js');

/**
 * @param {string} data - Stringified JSON data
 * @param {string} apiKey - Project API key
 * @returns {string} Encrypted data in hex format
 */
const encryptGCM = (data, apiKey) => {
    const hashedKey = CryptoJS.SHA256(apiKey);
    const iv = CryptoJS.lib.WordArray.random(12);
    
    // GCM mode is not directly supported in crypto-js, 
    // so it's recommended to use Node.js crypto module.
    // Below is a conceptual example.
    
    // For actual implementation, use Node.js crypto module
    throw new Error('GCM mode is not supported in crypto-js. Please use Node.js crypto module.');
};

/**
 * @param {string} encryptedHex - Hex encoded encrypted data
 * @param {string} apiKey - Project API key
 * @returns {string} Decrypted data
 */
const decryptGCM = (encryptedHex, apiKey) => {
    // crypto-js doesn't support GCM, so use Node.js crypto module
    throw new Error('GCM mode is not supported in crypto-js. Please use Node.js crypto module.');
};

import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.HexFormat;

public class GCMEncryption {
    private static final int GCM_IV_LENGTH = 12;
    private static final int GCM_TAG_LENGTH = 16;

    /**
     * @param data - Stringified JSON data
     * @param apiKey - Project API key
     * @return Encrypted data in hex format (IV + ciphertext + tag)
     */
    public static String encryptGCM(String data, String apiKey) throws Exception {
        // Hash the API key using SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        // Create AES key for encryption
        SecretKeySpec secretKey = new SecretKeySpec(hashedKey, "AES");
        
        // Initialize Cipher in GCM mode
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        
        // Generate 12-byte IV
        byte[] iv = new byte[GCM_IV_LENGTH];
        SecureRandom random = new SecureRandom();
        random.nextBytes(iv);
        
        // Set GCM parameters (tag length 128 bits)
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, gcmSpec);
        
        // Encrypt the data
        byte[] encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
        
        // Combine IV + ciphertext + tag and encode as hex
        byte[] result = new byte[iv.length + encryptedBytes.length];
        System.arraycopy(iv, 0, result, 0, iv.length);
        System.arraycopy(encryptedBytes, 0, result, iv.length, encryptedBytes.length);
        
        return HexFormat.of().formatHex(result);
    }

    /**
     * @param encryptedHex - Hex encoded encrypted data
     * @param apiKey - Project API key
     * @return Decrypted data
     */
    public static String decryptGCM(String encryptedHex, String apiKey) throws Exception {
        // Hash the API key using SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        // Create AES key for decryption
        SecretKeySpec secretKey = new SecretKeySpec(hashedKey, "AES");
        
        // Convert hex string to byte array
        byte[] encryptedData = HexFormat.of().parseHex(encryptedHex);
        
        // Separate IV and ciphertext
        byte[] iv = new byte[GCM_IV_LENGTH];
        byte[] ciphertext = new byte[encryptedData.length - GCM_IV_LENGTH];
        System.arraycopy(encryptedData, 0, iv, 0, GCM_IV_LENGTH);
        System.arraycopy(encryptedData, GCM_IV_LENGTH, ciphertext, 0, ciphertext.length);
        
        // Initialize Cipher in GCM mode
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, gcmSpec);
        
        // Decrypt the data
        byte[] decryptedBytes = cipher.doFinal(ciphertext);
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }
}

import os
import base64
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

def hashed_key(api_key: str) -> bytes:
    """Hash API key using SHA-256 to generate 32-byte key"""
    digest = hashes.Hash(hashes.SHA256())
    digest.update(api_key.encode("utf-8"))
    return digest.finalize()

def encrypt_gcm(data: str, api_key: str) -> str:
    """
    Encrypt data using AES-256-GCM method.
    
    Args:
        data: JSON string to encrypt
        api_key: Project API key
        
    Returns:
        hex format encrypted data (IV + ciphertext + tag)
    """
    key = hashed_key(api_key)
    iv = os.urandom(12)  # Generate 12-byte IV
    aesgcm = AESGCM(key)
    
    # Encrypt data (includes authentication tag)
    ct_tag = aesgcm.encrypt(iv, data.encode("utf-8"), None)
    
    # Combine IV + ciphertext + tag and encode as hex
    result = iv + ct_tag
    return result.hex()

def decrypt_gcm(encrypted_hex: str, api_key: str) -> str:
    """
    Decrypt data encrypted using AES-256-GCM method.
    
    Args:
        encrypted_hex: hex format encrypted data
        api_key: Project API key
        
    Returns:
        decrypted data
    """
    key = hashed_key(api_key)
    encrypted_data = bytes.fromhex(encrypted_hex)
    
    # Separate IV and ciphertext+tag
    iv = encrypted_data[:12]
    ct_tag = encrypted_data[12:]
    
    aesgcm = AESGCM(key)
    decrypted_data = aesgcm.decrypt(iv, ct_tag, None)
    return decrypted_data.decode("utf-8")

Decryption Example

Below are examples of decrypting data encrypted with AES-256

    var crypto = require('crypto');

  /**
  * @param {string} encryptedData
  * @param {string} apiKey
  * @returns {string} Decrypted data
  */
  function decrypt(encryptedData, apiKey) {
    var hashedKey = crypto.createHash('sha256').update(apiKey).digest();
    var decipher = crypto.createDecipheriv('aes-256-ecb', hashedKey, null);
    return decipher.update(encryptedData, 'base64', 'utf8') + decipher.final('utf8');
  }

const CryptoJS = require('crypto-js');

const decrypt = (encryptedData, apiKey) => {
  const hashedKey = CryptoJS.SHA256(apiKey);
  const decrypted = CryptoJS.AES.decrypt(encryptedData, hashedKey, {
    mode: CryptoJS.mode.ECB
  });
  return decrypted.toString(CryptoJS.enc.Utf8);
};

GCM Decryption Example

Below are examples of decrypting data encrypted with AES-256-GCM

var crypto = require('crypto');

/**
 * @param {string} encryptedHex - Hex encoded encrypted data (IV + ciphertext + tag)
 * @param {string} apiKey - Project API key
 * @returns {string} Decrypted data
 */
function decryptGCM(encryptedHex, apiKey) {
    var hashedKey = crypto.createHash('sha256').update(apiKey).digest();
    var encryptedBuffer = Buffer.from(encryptedHex, 'hex');
    
    // Separate IV, ciphertext, and tag
    var iv = encryptedBuffer.slice(0, 12);
    var tag = encryptedBuffer.slice(-16);
    var encrypted = encryptedBuffer.slice(12, -16);
    
    var decipher = crypto.createDecipheriv('aes-256-gcm', hashedKey, iv);
    decipher.setAuthTag(tag);
    
    var decrypted = decipher.update(encrypted);
    decrypted = Buffer.concat([decrypted, decipher.final()]);
    
    return decrypted.toString('utf8');
}

const CryptoJS = require('crypto-js');

/**
 * @param {string} encryptedHex - Hex encoded encrypted data
 * @param {string} apiKey - Project API key
 * @returns {string} Decrypted data
 */
const decryptGCM = (encryptedHex, apiKey) => {
    // crypto-js doesn't support GCM, so use Node.js crypto module
    throw new Error('GCM mode is not supported in crypto-js. Please use Node.js crypto module.');
};

import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HexFormat;

public class GCMDecryption {
    private static final int GCM_IV_LENGTH = 12;
    private static final int GCM_TAG_LENGTH = 16;

    /**
     * @param encryptedHex - Hex encoded encrypted data (IV + ciphertext + tag)
     * @param apiKey - Project API key
     * @return Decrypted data
     */
    public static String decryptGCM(String encryptedHex, String apiKey) throws Exception {
        // Hash the API key using SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        // Create AES key for decryption
        SecretKeySpec secretKey = new SecretKeySpec(hashedKey, "AES");
        
        // Convert hex string to byte array
        byte[] encryptedData = HexFormat.of().parseHex(encryptedHex);
        
        // Separate IV and ciphertext+tag
        byte[] iv = new byte[GCM_IV_LENGTH];
        byte[] ciphertext = new byte[encryptedData.length - GCM_IV_LENGTH];
        System.arraycopy(encryptedData, 0, iv, 0, GCM_IV_LENGTH);
        System.arraycopy(encryptedData, GCM_IV_LENGTH, ciphertext, 0, ciphertext.length);
        
        // Initialize Cipher in GCM mode
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, gcmSpec);
        
        // Decrypt the data
        byte[] decryptedBytes = cipher.doFinal(ciphertext);
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }
}

import os
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

def hashed_key(api_key: str) -> bytes:
    """Hash API key using SHA-256 to generate 32-byte key"""
    digest = hashes.Hash(hashes.SHA256())
    digest.update(api_key.encode("utf-8"))
    return digest.finalize()

def decrypt_gcm(encrypted_hex: str, api_key: str) -> str:
    """
    Decrypt data encrypted using AES-256-GCM method.
    
    Args:
        encrypted_hex: hex format encrypted data (IV + ciphertext + tag)
        api_key: Project API key
        
    Returns:
        decrypted data
    """
    key = hashed_key(api_key)
    encrypted_data = bytes.fromhex(encrypted_hex)
    
    # Separate IV and ciphertext+tag
    iv = encrypted_data[:12]
    ct_tag = encrypted_data[12:]
    
    aesgcm = AESGCM(key)
    decrypted_data = aesgcm.decrypt(iv, ct_tag, None)
    return decrypted_data.decode("utf-8")

4. Secure Data Transfer Options

Encrypt data for secure transmission in API methods (GET, POST, PATCH) and WEBHOOKs. API methods use the AES-256-ECB encryption method, while WEBHOOKs use AES-256-CBC encryption. Ensure that secure data transfer is enabled before using it to protect sensitive information. When Secure Data Transfer is enabled, encrypt the whole request payload as a single JSON object with AES-256-ECB before sending it. Where the ciphertext goes depends on the HTTP method.

Method	Where the ciphertext goes
`GET`	The `data` query parameter — URL-encode it exactly once
`POST` · `PATCH`	The request body — with `Content-Type: application/json`

On GET, encoding the ciphertext twice or not at all returns an empty result with no error. Wrap the ciphertext in encodeURIComponent() exactly once.

See the key features and descriptions below for how to encrypt.

body : encrypt({
		email : 'string',
		fullName : 'string',
		issuingCountry : 'string',
		birthDate: 'string'
		...
	})

Responses include encrypted data and the “isEncrypted” flag.

body : {
    "data": "encrypted-string",
    "isEncrypted": true
}

4-1. Key Features

GET, POST, PATCH requests are encrypted using AES-256-ECB
WEBHOOK data is encrypted using AES-256-CBC
Ensures data integrity and authentication through PKI
Enhances data protection during transmission

4-2. API Request Data Encryption (AES-256-ECB)

const CryptoJS = require('crypto-js');

function encryptECB(data, apiKey) {
    const hashedKey = CryptoJS.SHA256(apiKey);
    const key = CryptoJS.lib.WordArray.create(hashedKey.words.slice(0, 8), 32);
    const encrypted = CryptoJS.AES.encrypt(JSON.stringify(data), key, {
        mode: CryptoJS.mode.ECB
    });
    return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
}

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Base64;
import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class Encryptor {
    public static String encryptECB(JsonObject data, String apiKey) throws Exception {
        Gson gson = new Gson();
        String jsonData = gson.toJson(data);
        
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] rawKeyBytes = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        byte[] hashedKey = new byte[32];
        System.arraycopy(rawKeyBytes, 0, hashedKey, 0, 32);
        SecretKeySpec key = new SecretKeySpec(hashedKey, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        
        byte[] encryptedBytes = cipher.doFinal(jsonData.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }
}

4-3. API Data Decryption (AES-256-ECB)

const CryptoJS = require('crypto-js');

function decryptECB(encryptedData, apiKey) {
    const hashedKey = CryptoJS.SHA256(apiKey);
    const key = CryptoJS.lib.WordArray.create(hashedKey.words.slice(0, 8), 32);
    const cipherParams = CryptoJS.lib.CipherParams.create({
        ciphertext: CryptoJS.enc.Base64.parse(encryptedData)
    });
    const decrypted = CryptoJS.AES.decrypt(cipherParams, key, {
        mode: CryptoJS.mode.ECB
    });
    return JSON.parse(decrypted.toString(CryptoJS.enc.Utf8));
}

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Base64;
import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class Encryptor {
    public static JsonObject decryptECB(String encryptedData, String apiKey) throws Exception {
        Gson gson = new Gson();
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        byte[] aesCompatibleKey = new byte[32];
        System.arraycopy(hashedKey, 0, aesCompatibleKey, 0, 32);
        SecretKeySpec key = new SecretKeySpec(aesCompatibleKey, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key);
        
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        String jsonData = new String(decryptedBytes, StandardCharsets.UTF_8);
        return gson.fromJson(jsonData, JsonObject.class);
    }
}

4-4. WEBHOOK Data Encryption (AES-256-CBC)

const CryptoJS = require('crypto-js');

function generateKeyAndIV(apiKey) {
    const hashedKey = CryptoJS.SHA256(apiKey);
    const key = CryptoJS.lib.WordArray.create(hashedKey.words.slice(0, 8), 32);
    const iv = CryptoJS.lib.WordArray.create(hashedKey.words.slice(8, 12), 16);
    return { key, iv };
}

function encryptCBC(data, apiKey) {
    const { key, iv } = generateKeyAndIV(apiKey);
    const encrypted = CryptoJS.AES.encrypt(JSON.stringify(data), key, { iv: iv, mode: CryptoJS.mode.CBC });
    return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
}

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Base64;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.util.Arrays;

public class Encryptor {
    public static String encryptCBC(JsonObject data, String apiKey) throws Exception {
        String jsonData = new Gson().toJson(data);
        
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        byte[] keyBytes = Arrays.copyOf(hash, 32);
        SecretKeySpec key = new SecretKeySpec(keyBytes, "AES");
        
        byte[] ivBytes = new byte[16];
        Arrays.fill(ivBytes, (byte) 0);
        IvParameterSpec iv = new IvParameterSpec(ivBytes);
        
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key, iv);
        
        byte[] encryptedBytes = cipher.doFinal(jsonData.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }
}

4-5. WEBHOOK Data Decryption (AES-256-CBC)

const CryptoJS = require('crypto-js');

function generateKeyAndIV(apiKey) {
    const hashedKey = CryptoJS.SHA256(apiKey);
    const key = CryptoJS.lib.WordArray.create(hashedKey.words.slice(0, 8), 32);
    const iv = CryptoJS.lib.WordArray.create(hashedKey.words.slice(8, 12), 16);
    return { key, iv };
}

function decryptCBC(encryptedData, apiKey) {
    const { key, iv } = generateKeyAndIV(apiKey);
    
    // Create cipher params for decryption
    const cipherParams = CryptoJS.lib.CipherParams.create({
        ciphertext: CryptoJS.enc.Base64.parse(encryptedData)
    });
    
    // Decrypt the data
    const decrypted = CryptoJS.AES.decrypt(cipherParams, key, {
        iv: iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
    });
    
    return JSON.parse(decrypted.toString(CryptoJS.enc.Utf8));
}

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Base64;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.util.Arrays;

public class Encryptor {
    public static JsonObject decryptCBC(String encryptedData, String apiKey) throws Exception {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        byte[] keyBytes = Arrays.copyOf(hash, 32);
        SecretKeySpec key = new SecretKeySpec(keyBytes, "AES");
        
        byte[] ivBytes = new byte[16];
        Arrays.fill(ivBytes, (byte) 0);
        IvParameterSpec iv = new IvParameterSpec(ivBytes);
        
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key, iv);
        
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        String jsonData = new String(decryptedBytes, StandardCharsets.UTF_8);
        
        return new Gson().fromJson(jsonData, JsonObject.class);
    }
}

Getting Started

Liveform URL

Security

Developer's Guide MCP

Data Encryption and Decryption

Encryption and Decryption Tool

Encryption & Decryption Tool guide

Encryption Options

Types of Encryption Modules

Query String Encryption

Secure Data Transmission Options

Encryption/Decryption Methods

1. Types of Encryption Modules

Types of Encryption Keys

2. Query String Encryption

3. Query String Encryption and Decryption Methods

3-1. Key Generation Process

4. Secure Data Transfer Options

4-1. Key Features

4-2. API Request Data Encryption (AES-256-ECB)

4-3. API Data Decryption (AES-256-ECB)

4-4. WEBHOOK Data Encryption (AES-256-CBC)

4-5. WEBHOOK Data Decryption (AES-256-CBC)

​Encryption and Decryption Tool

Encryption & Decryption Tool guide

​Encryption Options

Types of Encryption Modules

Query String Encryption

Secure Data Transmission Options

Encryption/Decryption Methods

​1. Types of Encryption Modules

​Types of Encryption Keys

​2. Query String Encryption

​3. Query String Encryption and Decryption Methods

​3-1. Key Generation Process

​4. Secure Data Transfer Options

​4-1. Key Features

​4-2. API Request Data Encryption (AES-256-ECB)

​4-3. API Data Decryption (AES-256-ECB)

​4-4. WEBHOOK Data Encryption (AES-256-CBC)

​4-5. WEBHOOK Data Decryption (AES-256-CBC)

Encryption and Decryption Tool

Encryption Options

1. Types of Encryption Modules

Types of Encryption Keys

2. Query String Encryption

3. Query String Encryption and Decryption Methods

3-1. Key Generation Process

4. Secure Data Transfer Options

4-1. Key Features

4-2. API Request Data Encryption (AES-256-ECB)

4-3. API Data Decryption (AES-256-ECB)

4-4. WEBHOOK Data Encryption (AES-256-CBC)

4-5. WEBHOOK Data Decryption (AES-256-CBC)