Data Encryption and Decryption

Encryption and Decryption Tool

For development purposes, provide the Encryption and Decryption Tool.
You may download it via this link and verify the results are accurate.cf> In macOS, it requires allowing launching this app in the “Privacy & Security” settings menu.

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. If this option is enabled, the request body must be encrypted. Inquire about a body parameter that is encrypted data. It is necessary to encrypt AES-256-ECB and refer to the Key Features and instructions on 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 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

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)