Hyperledger Composer v0.19能否在lib/*.js脚本中加密解密资产数据？

Yes, you absolutely can implement encryption and decryption of asset data within your Hyperledger Composer v0.19 lib/*.js transaction scripts—even though this isn’t explicitly called out in the official Composer docs. Since Composer v0.19 is built on top of Hyperledger Fabric v1.1 (which supports chaincode-level encryption/decryption with transient key parameters), you can leverage Node.js’s native crypto tools or Fabric’s chaincode capabilities directly in your scripts.

Here’s a practical breakdown of how to approach this:

1. Update your asset model to support encrypted data #

First, adjust your .cto model file to include fields for encrypted data (you’ll want to avoid storing plaintext sensitive data on the ledger long-term):

asset MyAsset identified by assetId {
  o String assetId
  o String? sensitiveData // Optional plaintext field (cleared after encryption)
  o String encryptedSensitiveData // Field to store encrypted data
}

transaction EncryptAsset {
  o String encryptionKey // Transient key passed via transaction
  --> MyAsset asset
}

transaction DecryptAsset {
  o String decryptionKey // Transient key passed via transaction
  --> MyAsset asset
}

2. Implement encryption logic in your script #

In your lib/*.js file, write a transaction function that takes the provided key and encrypts the sensitive asset data:

/**
 * Encrypt sensitive data in an asset
 * @param {org.example.EncryptAsset} tx
 * @transaction
 */
async function encryptAsset(tx) {
    const crypto = require('crypto');
    const asset = tx.asset;
    const encryptionKey = tx.encryptionKey;

    // Use AES-192 encryption (adjust algorithm to fit your security needs)
    const cipher = crypto.createCipher('aes192', encryptionKey);
    let encryptedData = cipher.update(asset.sensitiveData, 'utf8', 'hex');
    encryptedData += cipher.final('hex');

    // Update the asset: store encrypted data and clear plaintext
    asset.encryptedSensitiveData = encryptedData;
    asset.sensitiveData = null;

    // Save the updated asset to the registry
    const assetRegistry = await getAssetRegistry('org.example.MyAsset');
    await assetRegistry.update(asset);
}

3. Add decryption functionality #

Similarly, create a transaction function to decrypt the data when required:

/**
 * Decrypt sensitive data from an asset
 * @param {org.example.DecryptAsset} tx
 * @transaction
 */
async function decryptAsset(tx) {
    const crypto = require('crypto');
    const asset = tx.asset;
    const decryptionKey = tx.decryptionKey;

    // Use the matching algorithm for decryption
    const decipher = crypto.createDecipher('aes192', decryptionKey);
    let decryptedData = decipher.update(asset.encryptedSensitiveData, 'hex', 'utf8');
    decryptedData += decipher.final('utf8');

    // Use the decrypted data for transaction logic here
    // Note: Avoid storing decrypted data back on the ledger unless absolutely necessary
    console.log('Decrypted sensitive data:', decryptedData);
}

Key considerations to keep in mind #

• Key security: Never store encryption/decryption keys on the ledger. For better security than transaction fields, use Fabric’s transient map feature (which doesn’t write keys to transaction history).
• Algorithm selection: Pick an encryption algorithm supported by Node.js’s crypto module that aligns with your security requirements (AES, RSA, etc.).
• Composer limitations: Since Composer doesn’t wrap this functionality into a pre-built API, you’ll handle the crypto logic manually—but all Fabric v1.1 chaincode capabilities are accessible here.
• Performance impact: Encryption/decryption adds computational overhead, so test how this affects your network’s throughput before deploying to production.

内容的提问来源于stack exchange，提问作者dl_