Comment décoder et déchiffrer les données de réponse dans Apidog

Parfois, les données de réponse de l'API sont encodées ou chiffrées, et il peut être nécessaire de les convertir en texte clair lisible. Vous pouvez y parvenir en utilisant les bibliothèques JS intégrées dans Apidog ou en invoquant des langages de programmation externes tels que Python ou JavaScript pour le traitement.

Par exemple, des données encodées en Base64 peuvent être décodées à l'aide de la bibliothèque intégrée.

Ci-dessous, nous partagerons quelques exemples courants de décodage et de déchiffrement. Si vous n'avez pas encore installé Apidog, cliquez simplement sur le bouton pour commencer !

Décoder les données de réponse

Décoder Base64

Lorsqu'une API renvoie des données encodées en Base64, vous pouvez utiliser la bibliothèque CryptoJS intégrée à Apidog pour les décoder. Voici comment procéder :

Supposons que l'API renvoie les données encodées en Base64 suivantes :

{"data": "SGVsbG8gd29ybGQh"}

Vous pouvez décoder ces données Base64 avec un script comme celui-ci :

// Import CryptoJS library
const CryptoJS = require("crypto-js");

// Base64 encoded string (extracted from response data)let encodedData = {"data": "SGVsbG8gd29ybGQh"
};

// Decode Base64 datalet decodedData = CryptoJS.enc.Base64.parse(encodedData.data).toString(CryptoJS.enc.Utf8);

// Output the decoded result
console.log(decodedData); // "Hello, world!"

Dans Apidog, vous pouvez ajouter un script personnalisé dans la section "Post-request" avec la logique ci-dessus. Après avoir envoyé la requête, vous pouvez afficher les données décodées dans la "Console" du panneau de réponse.

De plus, vous pouvez stocker les données décodées dans une variable d'environnement pour une utilisation future, comme ceci :

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

Si la réponse JSON contient des données encodées en Base64, vous pouvez de même utiliser CryptoJS pour les décoder et définir les données JSON décodées comme corps de la réponse avec la méthode pm.response.setBody(). Voici un exemple pour une réponse JSON encodée en Base64 :

Pour le décoder et afficher les données JSON décodées dans le corps de la réponse, l'exemple de script est le suivant :

// Import CryptoJS library
const CryptoJS = require("crypto-js");

// Base64 encoded string (extracted from response data)let encodedData = pm.response.text();

// Decode Base64 datalet decodedData = CryptoJS.enc.Base64.parse(encodedData).toString(CryptoJS.enc.Utf8);

// Parse the decoded JSON stringlet jsonData = JSON.parse(decodedData);

// Set the parsed JSON data as the response body
pm.response.setBody(JSON.stringify(jsonData));

URLEncode Decode

Lorsque les données de réponse sont encodées en URL, vous pouvez utiliser la méthode intégrée decodeURIComponent() de JavaScript pour les décoder.

Par exemple, considérez une API qui renvoie la chaîne JSON encodée en URL suivante :

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

Vous pouvez décoder les valeurs de cette chaîne JSON comme ceci :

// This is the URL-encoded JSON data from the responselet response = {"name": "%E5%BC%A0%E4%B8%89","email": "qxhswppn%40gmail.com"
};

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

Déchiffrer les données de réponse

Déchiffrement AES

Pour déchiffrer le texte chiffré AES, vous devez fournir la clé ou le vecteur d'initialisation (IV) approprié. AES utilise un chiffrement symétrique, ce qui signifie que la même clé est utilisée pour le chiffrement et le déchiffrement. Si vous n'avez pas la clé ou l'IV correct(e), vous ne pouvez pas déchiffrer le texte chiffré.

En supposant que vous ayez le texte chiffré AES en mode ECB, vous pouvez utiliser la bibliothèque CryptoJS pour le déchiffrer dans Apidog comme ceci :

// Import CryptoJS libraryconst CryptoJS = require('crypto-js');

// Base64 encoded AES encrypted ciphertext (extracted from response data)const ciphertext = "Gig+YJFu4fLrrexzam/vblRV3hoT25hPZn0HoNoosHQ=";

// Key for decryption (ensure it is 16/24/32 bytes; typically read from an environment variable)const key = CryptoJS.enc.Utf8.parse('1234567891234567');

// AES Decryptconst decryptedBytes = CryptoJS.AES.decrypt(ciphertext, key, {
    mode: CryptoJS.mode.ECB, // Decryption mode
    padding: CryptoJS.pad.Pkcs7 // Padding method
});

// Convert decrypted byte array to UTF-8 stringconst originalText = decryptedBytes.toString(CryptoJS.enc.Utf8);

// Output the decrypted text
console.log(originalText); // "Hello，Apidog!"

Vous pouvez afficher les données déchiffrées dans la console de réponse.

Déchiffrement RSA

Pour déchiffrer le texte chiffré RSA, vous devez fournir la clé privée RSA correspondante, car RSA est un algorithme de chiffrement asymétrique. La paire de clés comprend une clé publique et une clé privée, et la clé privée est essentielle pour le déchiffrement.

Apidog inclut la bibliothèque jsrsasign (Mettre à jour la dernière version), que vous pouvez utiliser pour déchiffrer le texte chiffré RSA. Voici un exemple :

// Import the jsrsasign library
const jsrsasign = require('jsrsasign');

// Define the private key (typically read from environment variables)
const privateKeyPEM = `
-----BEGIN PRIVATE KEY-----
Private key...
-----END PRIVATE KEY-----
`;

// Define the ciphertext (typically extracted from response data)
const ciphertext = '';

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

Un exemple complet de référence pour le chiffrement et le déchiffrement RSA simples (notez que la version jsrsasign est 10.3.0, et la syntaxe des autres versions peut être incompatible), que vous pouvez exécuter dans un environnement Node.js et effectuer des opérations de chiffrement ou de déchiffrement dans Apidog selon les besoins :

const rsa = require('jsrsasign');

// Generate RSA key pair
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);

// Encrypt with the public key
const plaintext = "Hello, Apidog!";
const pubKeyObj = rsa.KEYUTIL.getKey(publicKey);

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

// Decrypt with the private key
const prvKeyObj = rsa.KEYUTIL.getKey(privateKey);

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

Utilisation de programmes externes pour le déchiffrement

En plus d'utiliser les bibliothèques JS intégrées d'Apidog pour le déchiffrement, vous pouvez également invoquer un "programme externe" pour effectuer le déchiffrement. Pour plus d'informations sur l'utilisation de programmes externes, vous pouvez consulter le centre d'aide d'Apidog pour des instructions détaillées.

Exemple : déchiffrement RSA avec Node.js

Si vous souhaitez effectuer un déchiffrement RSA à l'aide de la bibliothèque node-forge dans Node.js, vous pouvez créer un fichier .js dans le répertoire des programmes externes pour implémenter la logique de déchiffrement. Voici comment procéder :

1. Créer un script de déchiffrement Tout d'abord, créez un fichier .js et implémentez la logique de déchiffrement. Puisque vous utiliserez la bibliothèque node-forge, installez-la dans ce répertoire à l'aide de npm ou yarn. Voici à quoi votre script pourrait ressembler :

// Import node-forge library
const forge = require('node-forge');
// Get command-line arguments
const args = process.argv.slice(2);
// Your private key (PEM format)
const privateKeyPem = `
-----BEGIN RSA PRIVATE KEY-----
private key……
-----END RSA PRIVATE KEY-----`;
// Encrypted ciphertext from command line
const encrypted = args[0];
// Convert PEM format private key to forge private key object
const privateKey = forge.pki.privateKeyFromPem(privateKeyPem);
// Convert Base64 encoded encrypted data to byte array
const encryptedBytes = forge.util.decode64(encrypted);
// Decrypt the data
const decrypted = privateKey.decrypt(encryptedBytes, 'RSA-OAEP');
// console.log() output will be captured by Apidog
console.log(decrypted);

1. Invoquer le programme externe dans Apidog Après avoir écrit le script de déchiffrement, vous pouvez utiliser la méthode pm.executeAsync() dans la section "Post-request" d'Apidog pour appeler ce programme externe. Assurez-vous que votre script de déchiffrement est placé dans le répertoire de programme externe correct et que le chemin que vous référencez est relatif à ce répertoire. Voici comment l'invoquer :

// Encrypted ciphertext (typically obtained from the response data)
const encrypted = 'iDqUyR3BpaTqpzq…………';
// External program path, passing parameters
const result = await pm.executeAsync('./nodejs-rsa/rsa.js', [`${encrypted}`]);
console.log('Result:', result);

Lorsque vous envoyez la requête dans Apidog, elle transmettra automatiquement le texte chiffré au programme externe que vous avez défini, effectuera le déchiffrement et capturera le résultat via console.log(), renvoyant finalement le texte clair déchiffré.

Ce type de déchiffrement n'est pas limité à Node.js, d'autres langages de programmation tels que Java, PHP, Python, Go, etc. peuvent effectuer des opérations et des appels similaires.

Conclusion

En utilisant les méthodes décrites dans cet article, vous pouvez décoder et déchiffrer efficacement les données de réponse dans Apidog, en les transformant en texte clair lisible. Essayez Apidog maintenant !