如何在鸿蒙系统中使用加解密算法库框架进行对称加密?

我正在开发一个需要保护用户数据的应用。请问,在鸿蒙系统中,如何使用@ohos.security.cryptoFramework加解密算法库框架来进行对称加密?我需要创建一个对称密钥,并使用它来对数据进行加密和解密。能否提供一个简单的示例代码来展示整个过程?

本文参与了 【 HarmonyOS NEXT 技术问答冲榜,等你来战!】欢迎正在阅读的你也加入。

阅读 449
avatarAI BotBETA
# 在鸿蒙系统中使用加解密算法库框架进行对称加密

在鸿蒙系统中,你可以使用`@ohos.security.cryptoFramework`加解密算法库框架来进行对称加密。以下是一个简单的示例代码,展示了如何创建一个对称密钥,并使用它来对数据进行加密和解密。

### 示例代码

import crypto from '@ohos.security.cryptoFramework';

// 定义一个函数来生成对称密钥
async function generateSymmetricKey() {

try {
    const algorithm = {
        name: "AES",
        length: 256
    };

    const key = await crypto.generateKey(algorithm, true, ["ENCRYPT", "DECRYPT"]);
    return key;
} catch (error) {
    console.error("Failed to generate symmetric key: ", error);
    return null;
}

}

// 定义一个函数来加密数据
async function encryptData(key, data) {

try {
    const algorithm = {
        name: "AES-GCM",
        length: 256
    };

    const iv = crypto.getRandomValues(new Uint8Array(12)); // 生成初始化向量
    const encodedData = new TextEncoder().encode(data);

    const encryptedData = await crypto.encrypt(
        {
            name: algorithm.name,
            iv: iv
        },
        key,
        encodedData
    );

    return {
        iv: iv,
        ciphertext: encryptedData
    };
} catch (error) {
    console.error("Failed to encrypt data: ", error);
    return null;
}

}

// 定义一个函数来解密数据
async function decryptData(key, iv, ciphertext) {

try {
    const algorithm = {
        name: "AES-GCM",
        length: 256
    };

    const decryptedData = await crypto.decrypt(
        {
            name: algorithm.name,
            iv: iv
        },
        key,
        ciphertext
    );

    const decodedData = new TextDecoder().decode(decryptedData);
    return decodedData;
} catch (error) {
    console.error("Failed to decrypt data: ", error);
    return null;
}

}

// 使用示例
(async () => {

const key = await generateSymmetricKey();
if (!key) {
    return;
}

const data = "Hello, HarmonyOS!";
const encrypted = await encryptData(key, data);
if (!encrypted) {
    return;
}

console.log("Encrypted data: ", encrypted);

const decrypted = await decryptData(key, encrypted.iv, encrypted.ciphertext);
if (decrypted) {
    console.log("Decrypted data: ", decrypted);
}

})();


### 解释

1. **生成对称密钥**:
   - 使用`crypto.generateKey`方法生成一个AES对称密钥。
   - `algorithm`对象指定了加密算法为AES,密钥长度为256位。
   - `true`表示生成的密钥是可提取的。
   - `["ENCRYPT", "DECRYPT"]`指定了密钥的用途。

2. **加密数据**:
   - 使用`crypto.encrypt`方法进行加密。
   - `algorithm`对象指定了加密算法为AES-GCM,密钥长度为256位。
   - 生成一个12字节的初始化向量(IV)。
   - 使用`TextEncoder`将待加密的字符串数据编码为字节数组。
   - 加密后返回包含IV和密文的对象。

3. **解密数据**:
   - 使用`crypto.decrypt`方法进行解密。
   - `algorithm`对象与加密时相同。
   - 提供加密时使用的IV和密文。
   - 解密后使用`TextDecoder`将字节数组解码为字符串。

这个示例展示了如何在鸿蒙系统中使用`@ohos.security.cryptoFramework`进行对称加密和解密的基本流程。你可以根据需要进行调整和扩展。
1 个回答

我觉得在鸿蒙系统中,你可以使用@ohos.security.cryptoFramework加解密算法库框架来进行对称加密。以下是一个简单的示例代码,展示了如何创建对称密钥并使用它来对数据进行加密和解密:

typescript
import { cryptoFramework } from '@ohos.security.cryptoFramework';
 
// 创建一个对称密钥生成器
let symKeyGenerator = cryptoFramework.createSymKeyGenerator('AES256');
 
// 生成对称密钥
symKeyGenerator.generateSymKey((err, symKey) => {
    if (err) {
        console.error('Failed to generate symmetric key:', err);
        return;
    }
 
    // 初始化Cipher对象进行加密
    let cipher = cryptoFramework.createCipher('AES256|CBC|PKCS7');
    cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, (err) => {
        if (err) {
            console.error('Failed to initialize cipher:', err);
            return;
        }
 
        // 待加密的数据
        let plainText = 'This is a secret message';
        let dataBlob = { data: new TextEncoder().encode(plainText) };
 
        // 加密数据
        cipher.update(dataBlob, (err, encryptedData) => {
            if (err) {
                console.error('Failed to encrypt data:', err);
                return;
            }
 
            // 完成加密
            cipher.doFinal(null, (err, finalData) => {
                if (err) {
                    console.error('Failed to finalize encryption:', err);
                    return;
                }
 
                // 加密完成,encryptedData和finalData拼接起来就是最终的密文
                let encryptedMessage = new Uint8Array(encryptedData.data.length + finalData.data.length);
                encryptedMessage.set(encryptedData.data, 0);
                encryptedMessage.set(finalData.data, encryptedData.data.length);
 
                console.log('Encrypted message:', encryptedMessage);
 
                // 初始化Cipher对象进行解密
                let decryptCipher = cryptoFramework.createCipher('AES256|CBC|PKCS7');
                decryptCipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, (err) => {
                    if (err) {
                        console.error('Failed to initialize decrypt cipher:', err);
                        return;
                    }
 
                    // 解密数据
                    decryptCipher.update(encryptedMessage, (err, decryptedData) => {
                        if (err) {
                            console.error('Failed to decrypt data:', err);
                            return;
                        }
 
                        // 完成解密
                        decryptCipher.doFinal(null, (err, finalDecryptedData) => {
                            if (err) {
                                console.error('Failed to finalize decryption:', err);
                                return;
                            }
 
                            // 解密完成,decryptedData和finalDecryptedData拼接起来就是最终的明文
                            let decryptedMessage = new Uint8Array(decryptedData.data.length + finalDecryptedData.data.length);
                            decryptedMessage.set(decryptedData.data, 0);
                            decryptedMessage.set(finalDecryptedData.data, decryptedData.data.length);
 
                            console.log('Decrypted message:', new TextDecoder().decode(decryptedMessage));
                        });
                    });
                });
            });
        });
    });
});

本文参与了 【 HarmonyOS NEXT 技术问答冲榜,等你来战!】欢迎正在阅读的你也加入。

撰写回答
你尚未登录,登录后可以
  • 和开发者交流问题的细节
  • 关注并接收问题和回答的更新提醒
  • 参与内容的编辑和改进,让解决方法与时俱进