Cómo decodificar y descifrar datos de respuesta en Apidog

A veces, los datos de respuesta de la API están codificados o cifrados, y puede ser necesario convertirlos en texto plano legible. Puedes lograr esto utilizando las bibliotecas JS integradas en Apidog o invocando lenguajes de programación externos como Python o JavaScript para el procesamiento.

Por ejemplo, los datos codificados en Base64 se pueden decodificar utilizando la biblioteca integrada.

A continuación, compartiremos algunos ejemplos comunes de decodificación y descifrado. Si aún no has instalado Apidog, ¡simplemente haz clic en el botón para comenzar!

Decodificación de datos de respuesta

Decodificación Base64

Cuando una API devuelve datos codificados en Base64, puedes usar la biblioteca CryptoJS integrada en Apidog para decodificarlos. Aquí te mostramos cómo hacerlo:

Supongamos que la API devuelve los siguientes datos codificados en Base64:

{"data": "SGVsbG8gd29ybGQh"}

Puedes decodificar estos datos Base64 con un script como este:

// Importar la biblioteca CryptoJS
const CryptoJS = require("crypto-js");

// Cadena codificada en Base64 (extraída de los datos de respuesta)let encodedData = {"data": "SGVsbG8gd29ybGQh"
};

// Decodificar datos Base64let decodedData = CryptoJS.enc.Base64.parse(encodedData.data).toString(CryptoJS.enc.Utf8);

// Imprimir el resultado decodificado
console.log(decodedData); // "¡Hola, mundo!"

En Apidog, puedes agregar un script personalizado en la sección "Post-request" con la lógica anterior. Después de enviar la solicitud, puedes ver los datos decodificados en la "Consola" del panel de respuesta.

Además, puedes almacenar los datos decodificados en una variable de entorno para su uso futuro, así:

pm.environment.set("decodedData", decodedData);

Si la respuesta JSON contiene datos codificados en Base64, puedes usar CryptoJS de manera similar para decodificarlos y establecer los datos JSON decodificados como el cuerpo de la respuesta con el método pm.response.setBody(). Aquí hay un ejemplo para una respuesta JSON codificada en Base64:

Para decodificarlo y mostrar los datos JSON decodificados en el cuerpo de la respuesta, el script de ejemplo es el siguiente:

// Importar la biblioteca CryptoJS
const CryptoJS = require("crypto-js");

// Cadena codificada en Base64 (extraída de los datos de respuesta)let encodedData = pm.response.text();

// Decodificar datos Base64let decodedData = CryptoJS.enc.Base64.parse(encodedData).toString(CryptoJS.enc.Utf8);

// Analizar la cadena JSON decodificadalet jsonData = JSON.parse(decodedData);

// Establecer los datos JSON analizados como el cuerpo de la respuesta
pm.response.setBody(JSON.stringify(jsonData));

Decodificación URLEncode

Cuando los datos de respuesta están codificados en URL, puedes usar el método decodeURIComponent() integrado de JavaScript para decodificarlos.

Por ejemplo, considera una API que devuelve la siguiente cadena JSON codificada en URL:

{"name": "%E5%BC%A0%E4%B8%89","email": "qxhswppn%40gmail.com"
}

Puedes decodificar los valores de esta cadena JSON así:

// Estos son los datos JSON codificados en URL de la respuestalet response = {"name": "%E5%BC%A0%E4%B8%89","email": "qxhswppn%40gmail.com"
};

// Decodificar usando decodeURIComponentlet decodedName = decodeURIComponent(response.name);
let decodedEmail = decodeURIComponent(response.email);
console.log(decodedName);  // "Jason"
console.log(decodedEmail);  // "qxhswppn@gmail.com"

Descifrado de datos de respuesta

Descifrado AES

Para descifrar el texto cifrado AES, debes proporcionar la clave o el vector de inicialización (IV) apropiados. AES utiliza el cifrado simétrico, lo que significa que se utiliza la misma clave tanto para el cifrado como para el descifrado. Si no tienes la clave o el IV correctos, no puedes descifrar el texto cifrado.

Suponiendo que tienes el texto cifrado AES en modo ECB, puedes usar la biblioteca CryptoJS para descifrarlo en Apidog así:

// Importar la biblioteca CryptoJSconst CryptoJS = require('crypto-js');

// Texto cifrado AES codificado en Base64 (extraído de los datos de respuesta)const ciphertext = "Gig+YJFu4fLrrexzam/vblRV3hoT25hPZn0HoNoosHQ=";

// Clave para el descifrado (asegúrate de que tenga 16/24/32 bytes; normalmente se lee de una variable de entorno)const key = CryptoJS.enc.Utf8.parse('1234567891234567');

// Descifrado AESconst decryptedBytes = CryptoJS.AES.decrypt(ciphertext, key, {
    mode: CryptoJS.mode.ECB, // Modo de descifrado
    padding: CryptoJS.pad.Pkcs7 // Método de relleno
});

// Convertir la matriz de bytes descifrados a una cadena UTF-8const originalText = decryptedBytes.toString(CryptoJS.enc.Utf8);

// Imprimir el texto descifrado
console.log(originalText); // "¡Hola, Apidog!"

Puedes ver los datos descifrados en la consola de respuesta.

Descifrado RSA

Para descifrar el texto cifrado RSA, debes proporcionar la clave privada RSA correspondiente, ya que RSA es un algoritmo de cifrado asimétrico. El par de claves comprende una clave pública y una clave privada, y la clave privada es esencial para el descifrado.

Apidog incluye la biblioteca jsrsasign (actualiza a la última versión), que puedes usar para descifrar el texto cifrado RSA. Aquí hay un ejemplo:

// Importar la biblioteca jsrsasign
const jsrsasign = require('jsrsasign');

// Definir la clave privada (normalmente se lee de las variables de entorno)
const privateKeyPEM = `
-----BEGIN PRIVATE KEY-----
Private key...
-----END PRIVATE KEY-----
`;

// Definir el texto cifrado (normalmente se extrae de los datos de respuesta)
const ciphertext = '';

// Descifrar
const prvKeyObj = jsrsasign.KEYUTIL.getKey(privateKeyPEM);
const decrypted = jsrsasign.KJUR.crypto.Cipher.decrypt(ciphertext, prvKeyObj);
console.log(decrypted);

Una referencia de ejemplo completa para el cifrado y descifrado RSA simple (ten en cuenta que la versión de jsrsasign es 10.3.0, y la sintaxis de otras versiones puede ser incompatible), que puedes ejecutar en un entorno Node.js y realizar operaciones de cifrado o descifrado en Apidog según sea necesario:

const rsa = require('jsrsasign');

// Generar par de claves RSA
const keypair = rsa.KEYUTIL.generateKeypair("RSA", 2048);
const publicKey = rsa.KEYUTIL.getPEM(keypair.pubKeyObj);
const privateKey = rsa.KEYUTIL.getPEM(keypair.prvKeyObj, "PKCS8PRV");

console.log("Public Key:", publicKey);
console.log("Private Key:", privateKey);

// Cifrar con la clave pública
const plaintext = "Hello, Apidog!";
const pubKeyObj = rsa.KEYUTIL.getKey(publicKey);

const encryptedHex = rsa.KJUR.crypto.Cipher.encrypt(plaintext, pubKeyObj);
console.log("Encrypted Key:", encryptedHex);

// Descifrar con la clave privada
const prvKeyObj = rsa.KEYUTIL.getKey(privateKey);

const decrypted = rsa.KJUR.crypto.Cipher.decrypt(encryptedHex, prvKeyObj);
console.log("Decrypted Plaintext:", decrypted);

Uso de programas externos para el descifrado

Además de usar las bibliotecas JS integradas de Apidog para el descifrado, también puedes invocar un "programa externo" para realizar el descifrado. Para obtener más información sobre el uso de programas externos, puedes consultar el centro de ayuda de Apidog para obtener instrucciones detalladas.

Ejemplo: Descifrado RSA con Node.js

Si deseas realizar el descifrado RSA utilizando la biblioteca node-forge en Node.js, puedes crear un archivo .js en el Directorio de programas externos para implementar la lógica de descifrado. Aquí te mostramos cómo hacerlo:

1. Crear script de descifrado Primero, crea un archivo .js e implementa la lógica de descifrado. Dado que usarás la biblioteca node-forge, instálala en ese directorio usando npm o yarn. Así es como podría verse tu script:

// Importar la biblioteca node-forge
const forge = require('node-forge');
// Obtener argumentos de la línea de comandos
const args = process.argv.slice(2);
// Tu clave privada (formato PEM)
const privateKeyPem = `
-----BEGIN RSA PRIVATE KEY-----
private key……
-----END RSA PRIVATE KEY-----`;
// Texto cifrado encriptado desde la línea de comandos
const encrypted = args[0];
// Convertir la clave privada en formato PEM al objeto de clave privada forge
const privateKey = forge.pki.privateKeyFromPem(privateKeyPem);
// Convertir los datos cifrados codificados en Base64 a una matriz de bytes
const encryptedBytes = forge.util.decode64(encrypted);
// Descifrar los datos
const decrypted = privateKey.decrypt(encryptedBytes, 'RSA-OAEP');
// La salida de console.log() será capturada por Apidog
console.log(decrypted);

1. Invocar el programa externo en Apidog Después de escribir el script de descifrado, puedes usar el método pm.executeAsync() en la sección "Post-request" de Apidog para llamar a este programa externo. Asegúrate de que tu script de descifrado esté ubicado en el directorio de programas externos correcto y de que la ruta a la que haces referencia sea relativa a ese directorio. Aquí te mostramos cómo invocarlo:

// Texto cifrado (normalmente obtenido de los datos de respuesta)
const encrypted = 'iDqUyR3BpaTqpzq…………';
// Ruta del programa externo, pasando parámetros
const result = await pm.executeAsync('./nodejs-rsa/rsa.js', [`${encrypted}`]);
console.log('Result:', result);

Cuando envíes la solicitud en Apidog, automáticamente pasará el texto cifrado al programa externo que definiste, realizará el descifrado y capturará el resultado de salida a través de console.log(), devolviendo finalmente el texto plano descifrado.

Este tipo de descifrado no se limita a Node.js, otros lenguajes de programación como Java, PHP, Python, Go, etc. pueden realizar operaciones y llamadas similares.

Conclusión

Usando los métodos descritos en este artículo, puedes decodificar y descifrar eficazmente los datos de respuesta en Apidog, convirtiéndolos en texto plano legible. ¡Prueba Apidog ahora!