Cifrado y Descifrado de Datos

Herramienta de Cifrado y Descifrado

Para fines de desarrollo, proporcione la Herramienta de Cifrado y Descifrado.
Puede descargarla mediante este enlace y verifique que los resultados sean precisos.cf> En 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. Tipos de Módulos de Cifrado

Hay dos tipos de módulos de cifrado disponibles:

AES-256: Método de cifrado de bloque rápido y simple
GCM-256: Método de cifrado mejorado con características de autenticación e integridad

Tipos de Claves de Cifrado

Clave de API: Clave de API asignada al Proyecto
Clave de API Personalizada (secretKey): Nueva secretKey emitida desde Liveform para uso

2. Cifrado de Cadena de Consulta

Los datos sensibles enviados mediante cadenas de consulta de URL se cifran utilizando el método de cifrado AES-256-ECB o GCM-256.

Preparar los Datos en Formato JSON

Consulte el enlace siguiente para cada descripción de parámetroParámetros Clave de Cadena de Consulta

{
    "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"
}

Seleccionar el Módulo de Cifrado AES-256/GCM-256 y la Clave de API o secretKey

Realizar el Cifrado AES-256/GCM-256 Utilizando la Clave de API Proporcionada

Agregar los Datos Cifrados a la URL como el Parámetro de Consulta 'encrypted'

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

Precaución: Los siguientes parámetros de consulta no están cifrados: pid, lang, sid, action.
Los parámetros de consulta pid, lang y los parámetros de consulta sid, action utilizados en la página de “Proceso Adicional (Inyección)” no admiten cifrado.

3. Métodos de Cifrado y Descifrado de Cadena de Consulta

3-1. Proceso de Generación de Claves

AES-256 GCM-256

Generar Clave Hasheada

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

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

Ejemplo de Cifrado

A continuación se presentan ejemplos de cifrado de datos utilizando AES-256

  var crypto = require('crypto');

  /**
  * @param {string} data - Datos JSON convertidos a cadena
  * @param {string} apiKey - Clave de API del proyecto
  * @returns {string} Datos cifrados
  *
  * para cifrado exacto, use formatJSON.
  * ejemplo abajo,
  * const data = {
      userid: "10912301",
      email: "email@email.com"
  * };
  *
  * no use la forma directa de cadena, como
  * `{"userid":"10912301","email":"email@email.com"}`
  * que no es lo mismo que el cifrado esperado.
  */

  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 {
          // Hashear la clave de API utilizando SHA-256
          MessageDigest digest = MessageDigest.getInstance("SHA-256");
          byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
          
          // Asegurarse de que la clave tenga 32 bytes de longitud para compatibilidad con AES-256
          byte[] aesCompatibleKey = new byte[32];
          System.arraycopy(hashedKey, 0, aesCompatibleKey, 0, 32);
          
          // Crear la clave AES para el cifrado
          SecretKeySpec secretKey = new SecretKeySpec(hashedKey, "AES");
          
          // Inicializar el Cipher en modo AES/ECB/PKCS5Padding
          Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
          cipher.init(Cipher.ENCRYPT_MODE, secretKey);
          
          // Cifrar los datos
          byte[] encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
          
          // Devolver el resultado cifrado codificado en Base64
          return Base64.getEncoder().encodeToString(encryptedBytes);
      }
  }

Ejemplo de Cifrado GCM

A continuación se presentan ejemplos de cifrado de datos utilizando AES-256-GCM

var crypto = require('crypto');

/**
* @param {string} data - Datos JSON convertidos a cadena
* @param {string} apiKey - Clave de API del proyecto
* @returns {string} Datos cifrados en formato hexadecimal (IV + cifrado + etiqueta)
*
* El modo GCM proporciona cifrado autenticado e incluye IV y etiqueta de autenticación.
* El valor de retorno es una cadena hexadecimal codificada del IV de 12 bytes + cifrado + etiqueta de autenticación de 16 bytes.
*/
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 - Hexadecimal de datos cifrados
* @param {string} apiKey - Clave de API del proyecto
* @returns {string} Datos descifrados
*/
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 - Datos JSON convertidos a cadena
* @param {string} apiKey - Clave de API del proyecto
* @returns {string} Datos cifrados en formato hexadecimal
*/
const encryptGCM = (data, apiKey) => {
    const hashedKey = CryptoJS.SHA256(apiKey);
    const iv = CryptoJS.lib.WordArray.random(12);
    
    // El modo GCM no está directamente soportado en crypto-js, 
    // así que se recomienda utilizar el módulo crypto de Node.js.
    // A continuación se muestra un ejemplo conceptual.
    
    // Para la implementación real, utilice el módulo crypto de Node.js
    throw new Error('El modo GCM no está soportado en crypto-js. Por favor utilice el módulo crypto de Node.js.');
};

/**
* @param {string} encryptedHex - Hexadecimal de datos cifrados
* @param {string} apiKey - Clave de API del proyecto
* @returns {string} Datos descifrados
*/
const decryptGCM = (encryptedHex, apiKey) => {
    // crypto-js no soporta GCM, así que utilice el módulo crypto de Node.js
    throw new Error('El modo GCM no está soportado en crypto-js. Por favor utilice el módulo crypto de Node.js.');
};

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 - Datos JSON convertidos a cadena
    * @param apiKey - Clave de API del proyecto
    * @return Datos cifrados en formato hexadecimal (IV + cifrado + etiqueta)
    */
    public static String encryptGCM(String data, String apiKey) throws Exception {
        // Hashear la clave de API utilizando SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        // Crear clave AES para el cifrado
        SecretKeySpec secretKey = new SecretKeySpec(hashedKey, "AES");
        
        // Inicializar Cipher en modo GCM
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        
        // Generar IV de 12 bytes
        byte[] iv = new byte[GCM_IV_LENGTH];
        SecureRandom random = new SecureRandom();
        random.nextBytes(iv);
        
        // Establecer parámetros GCM (longitud de etiqueta 128 bits)
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, gcmSpec);
        
        // Cifrar los datos
        byte[] encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
        
        // Combinar IV + cifrado + etiqueta y codificar como hexadecimal
        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 - Hexadecimal de datos cifrados
    * @param apiKey - Clave de API del proyecto
    * @return Datos descifrados
    */
    public static String decryptGCM(String encryptedHex, String apiKey) throws Exception {
        // Hashear la clave de API utilizando SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        // Crear clave AES para el descifrado
        SecretKeySpec secretKey = new SecretKeySpec(hashedKey, "AES");
        
        // Convertir cadena hexadecimal a array de bytes
        byte[] encryptedData = HexFormat.of().parseHex(encryptedHex);
        
        // Separar IV y cifrado
        byte[] iv = new byte[GCM_IV_LENGTH];
        byte[] ciphertext = new byte[encryptedData.length - GCM_IV_LENGTH];
        System.arraycopy(encryptedData, 0, iv, 0, iv.length);
        System.arraycopy(encryptedData, GCM_IV_LENGTH, ciphertext, 0, ciphertext.length);
        
        // Inicializar Cipher en modo GCM
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, gcmSpec);
        
        // Descifrar los datos
        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:
    """Hashear la clave de API utilizando SHA-256 para generar una clave de 32 bytes"""
    digest = hashes.Hash(hashes.SHA256())
    digest.update(api_key.encode("utf-8"))
    return digest.finalize()

def encrypt_gcm(data: str, api_key: str) -> str:
    """
    Cifrar datos utilizando el método AES-256-GCM.
    
    Args:
        data: Cadena JSON para cifrar
        api_key: Clave de API del proyecto
        
    Returns:
        formato hexadecimal de datos cifrados (IV + cifrado + etiqueta)
    """
    key = hashed_key(api_key)
    iv = os.urandom(12)  # Generar IV de 12 bytes
    aesgcm = AESGCM(key)
    
    # Cifrar datos (incluye etiqueta de autenticación)
    ct_tag = aesgcm.encrypt(iv, data.encode("utf-8"), None)
    
    # Combinar IV + cifrado + etiqueta y codificar como hexadecimal
    result = iv + ct_tag
    return result.hex()

def decrypt_gcm(encrypted_hex: str, api_key: str) -> str:
    """
    Descifrar datos cifrados utilizando el método AES-256-GCM.
    
    Args:
        encrypted_hex: formato hexadecimal de datos cifrados
        api_key: Clave de API del proyecto
        
    Returns:
        datos descifrados
    """
    key = hashed_key(api_key)
    encrypted_data = bytes.fromhex(encrypted_hex)
    
    # Separar IV y cifrado+etiqueta
    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")

Ejemplo de Descifrado

A continuación se presentan ejemplos de descifrado de datos cifrados con AES-256

    var crypto = require('crypto');

  /**
  * @param {string} encryptedData
  * @param {string} apiKey
  * @returns {string} Datos descifrados
  */
  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);
};

Ejemplo de Descifrado GCM

A continuación se presentan ejemplos de descifrado de datos cifrados con AES-256-GCM

var crypto = require('crypto');

/**
* @param {string} encryptedHex - Hexadecimal de datos cifrados (IV + cifrado + etiqueta)
* @param {string} apiKey - Clave de API del proyecto
* @returns {string} Datos descifrados
*/
function decryptGCM(encryptedHex, apiKey) {
    var hashedKey = crypto.createHash('sha256').update(apiKey).digest();
    var encryptedBuffer = Buffer.from(encryptedHex, 'hex');
    
    // Separar IV, cifrado y etiqueta
    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 - Hexadecimal de datos cifrados
* @param {string} apiKey - Clave de API del proyecto
* @returns {string} Datos descifrados
*/
const decryptGCM = (encryptedHex, apiKey) => {
    // crypto-js no soporta GCM, así que utilice el módulo crypto de Node.js
    throw new Error('El modo GCM no está soportado en crypto-js. Por favor utilice el módulo crypto de Node.js.');
};

```java Java
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 - Hexadecimal de datos cifrados (IV + cifrado + etiqueta)
    * @param apiKey - Clave de API del proyecto
    * @return Datos descifrados
    */
    public static String decryptGCM(String encryptedHex, String apiKey) throws Exception {
        // Hashear la clave de API utilizando SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashedKey = digest.digest(apiKey.getBytes(StandardCharsets.UTF_8));
        
        // Crear clave AES para el descifrado
        SecretKeySpec key = new SecretKeySpec(hashedKey, "AES");
        
        // Convertir cadena hexadecimal a array de bytes
        byte[] encryptedData = HexFormat.of().parseHex(encryptedHex);
        
        // Separar IV y cifrado+etiqueta
        byte[] iv = new byte[GCM_IV_LENGTH];
        byte[] ciphertext = new byte[encryptedData.length - GCM_IV_LENGTH];
        System.arraycopy(encryptedData, 0, iv, 0, iv.length);
        System.arraycopy(encryptedData, GCM_IV_LENGTH, ciphertext, 0, ciphertext.length);
        
        // Inicializar Cipher en modo GCM
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.DECRYPT_MODE, key, gcmSpec);
        
        // Descifrar los datos
        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:
    """Hashear la clave de API utilizando SHA-256 para generar una clave de 32 bytes"""
    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:
    """
    Descifrar datos cifrados utilizando el método AES-256-GCM.
    
    Args:
        encrypted_hex: formato hexadecimal de datos cifrados (IV + cifrado + etiqueta)
        api_key: Clave de API del proyecto
        
    Returns:
        datos descifrados
    """
    key = hashed_key(api_key)
    encrypted_data = bytes.fromhex(encrypted_hex)
    
    # Separar IV y cifrado+etiqueta
    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. Opciones de Transferencia Segura de Datos

Cifre los datos para una transmisión segura en métodos de API (GET, POST, PATCH) y WEBHOOKs. Los métodos de API utilizan el método de cifrado AES-256-ECB, mientras que los WEBHOOKs utilizan AES-256-CBC. Asegúrese de que la transferencia segura de datos esté habilitada antes de usarla para proteger información sensible. Si esta opción está habilitada, el cuerpo de la solicitud debe estar cifrado. Consulte sobre un parámetro del cuerpo que sean datos cifrados. Es necesario cifrar AES-256-ECB y refiérase a las Características Principales y las instrucciones sobre cómo cifrar.

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

Las respuestas incluyen datos cifrados y la bandera “isEncrypted”.

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

4-1. Características Principales

Las solicitudes GET, POST, PATCH se cifran utilizando AES-256-ECB
Los datos de WEBHOOK se cifran utilizando AES-256-CBC
Garantiza la integridad de los datos y la autenticación a través de PKI
Mejora la protección de los datos durante la transmisión

4-2. Cifrado de Datos de Solicitud de API (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. Descifrado de Datos de API (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));
}



```java AES-256-ECB.java
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. Cifrado de Datos de WEBHOOK (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. Descifrado de Datos de WEBHOOK (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);
    
    // Crear parámetros de cifrado para descifrado
    const cipherParams = CryptoJS.lib.CipherParams.create({
        ciphertext: CryptoJS.enc.Base64.parse(encryptedData)
    });
    
    // Descifrar los datos
    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);
    }
}

Primeros Pasos

URL de Liveform

Seguridad

Guía del Desarrollador MCP

Cifrado y Descifrado de Datos

Herramienta de Cifrado y Descifrado

Encryption Options

Types of Encryption Modules

Query String Encryption

Secure Data Transmission Options

Encryption/Decryption Methods

1. Tipos de Módulos de Cifrado

Tipos de Claves de Cifrado

2. Cifrado de Cadena de Consulta

3. Métodos de Cifrado y Descifrado de Cadena de Consulta

3-1. Proceso de Generación de Claves

4. Opciones de Transferencia Segura de Datos

4-1. Características Principales

4-2. Cifrado de Datos de Solicitud de API (AES-256-ECB)

4-3. Descifrado de Datos de API (AES-256-ECB)

4-4. Cifrado de Datos de WEBHOOK (AES-256-CBC)

4-5. Descifrado de Datos de WEBHOOK (AES-256-CBC)

​Herramienta de Cifrado y Descifrado

​Encryption Options

Types of Encryption Modules

Query String Encryption

Secure Data Transmission Options

Encryption/Decryption Methods

​1. Tipos de Módulos de Cifrado

​Tipos de Claves de Cifrado

​2. Cifrado de Cadena de Consulta

​3. Métodos de Cifrado y Descifrado de Cadena de Consulta

​3-1. Proceso de Generación de Claves

​4. Opciones de Transferencia Segura de Datos

​4-1. Características Principales

​4-2. Cifrado de Datos de Solicitud de API (AES-256-ECB)

​4-3. Descifrado de Datos de API (AES-256-ECB)

​4-4. Cifrado de Datos de WEBHOOK (AES-256-CBC)

​4-5. Descifrado de Datos de WEBHOOK (AES-256-CBC)

Herramienta de Cifrado y Descifrado

Encryption Options

1. Tipos de Módulos de Cifrado

Tipos de Claves de Cifrado

2. Cifrado de Cadena de Consulta

3. Métodos de Cifrado y Descifrado de Cadena de Consulta

3-1. Proceso de Generación de Claves

4. Opciones de Transferencia Segura de Datos

4-1. Características Principales

4-2. Cifrado de Datos de Solicitud de API (AES-256-ECB)

4-3. Descifrado de Datos de API (AES-256-ECB)

4-4. Cifrado de Datos de WEBHOOK (AES-256-CBC)

4-5. Descifrado de Datos de WEBHOOK (AES-256-CBC)