跳到主要内容

密码算法功能介绍

openHiTLS基于密码算法标准提供了加解密、签名验证、哈希等功能。主要功能接口在算法模块中提供，在openHiTLS系统内为证书和TLS模块提供默认密码算法能力。

功能规格​

  • 加密解密：支持SM4、AES、CHACHA20对称加解密功能；支持SM2, RSA非对称加解密功能。
  • 签名验证：支持SM2、DSA、ED25519、RSA、ECDSA签名验证功能。
  • 密钥交换：支持SM2、X25519、ECDH密钥交换功能。
  • 密钥派生：支持PBKDF2、HKDF、SCRYPT、KDFTLS12密钥派生功能。
  • 完整性算法：支持HMAC 完整性保护功能。
  • 哈希计算：支持SM3、SHA2、SHA3、MD5、SHA1摘要计算功能。
  • 随机数生成：支持DRBG-HASH, DRBG-CTR, DRBG-HMAC随机数功能。

加解密示例

对称加解密​

对称加解密功能基于对称算法提供了加解密能力，如下以SM4-CBC算法为例，给出了对称加解密的示例代码，供适配参考。

示例代码​

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "crypt_eal_cipher.h" // 对称加解密接口头文件
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h" // 算法id列表
#include "crypt_errno.h" // 错误码列表

void *StdMalloc(uint32_t len) {
    return malloc((size_t)len);
}

void PrintLastError(void) {
    const char *file = NULL;
    uint32_t line = 0;
    BSL_ERR_GetLastErrorFileLine(&file, &line); // 获取错误发生的文件名和行数
    printf("failed at file %s at line %d\n", file, line);
}

BSL_SAL_MemCallback cb = {StdMalloc, free}; // 注册的内存分配接口

int main(void)
{
    uint8_t data[10] = {0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x1c, 0x14};
    uint8_t iv[16] = {0};
    uint8_t key[16] = {0};
    uint32_t dataLen = sizeof(data);
    uint8_t cipherText[100];
    uint8_t plainText[100];
    uint32_t outTotalLen = 0;
    uint32_t outLen = sizeof(cipherText);
    uint32_t cipherTextLen;
    int32_t ret;

    printf("plain text to be encrypted: "); // 输出明文
    for (uint32_t i = 0; i < dataLen; i++) {
        printf("%02x", data[i]);
    }
    printf("\n");

    // 初始化错误码模块
    BSL_ERR_Init();

    // 调用算法API接口之前需要调用BSL_SAL_RegMemCallback函数注册malloc和free函数。该步骤仅需执行一次。
    // 如果未注册并且默认能力没有被裁剪,使用默认linux实现
    BSL_SAL_RegMemCallback(&cb);

    // 创建上下文
    CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_SM4_CBC);
    if (ctx == NULL) {
        PrintLastError();
        BSL_ERR_DeInit();
        return 1;
    }
    // 初始化, 最后入参true为加密，false为解密
    ret = CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret); // 输出错误码，可借助错误码在crypt_errno.h中找到对应的错误信息
        PrintLastError();
        goto exit;
    }
    // 设置填充模式。
    ret = CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 输入待计算数据，该接口可以调用多次。此处outLen输入为cipherText长度，输出为处理的数据量
    ret = CRYPT_EAL_CipherUpdate(ctx, data, dataLen, cipherText, &outLen);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    outTotalLen += outLen;                     // 目前已处理数据量
    outLen = sizeof(cipherText) - outTotalLen; // cipherText剩余空间

    // 填充并处理最后一段数据
    ret = CRYPT_EAL_CipherFinal(ctx, cipherText + outTotalLen, &outLen);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    outTotalLen += outLen;
    printf("cipher text value is: "); // 输出密文

    for (uint32_t i = 0; i < outTotalLen; i++) {
        printf("%02x", cipherText[i]);
    }
    printf("\n");

    // 开始解密流程
    cipherTextLen = outTotalLen;
    outTotalLen = 0;
    outLen = sizeof(plainText);

    // 初始化, 设置为解密
    ret = CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), false);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret); // 输出错误码，可借助错误码在crypt_errno.h中找到对应的错误信息
        PrintLastError();
        goto exit;
    }

    // 设置填充模式，填充模式必须和加密的填充模式相同
    ret = CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 输入密文数据
    ret = CRYPT_EAL_CipherUpdate(ctx, cipherText, cipherTextLen, plainText, &outLen);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }
    outTotalLen += outLen;                    // 目前已处理数据量
    outLen = sizeof(plainText) - outTotalLen; // buffer剩余空间

    // 解密最后一段数据并去填充
    ret = CRYPT_EAL_CipherFinal(ctx, plainText + outTotalLen, &outLen);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    outTotalLen += outLen;

    printf("decrypted plain text value is: "); // 输出明文
    for (uint32_t i = 0; i < outTotalLen; i++) {
        printf("%02x", plainText[i]);
    }
    printf("\n");

    if (outTotalLen != dataLen || memcmp(plainText, data, dataLen) != 0) {
        printf("plaintext comparison failed\n");
        goto exit;
    }
    printf("pass \n");

exit:
    // 释放上下文内存
    CRYPT_EAL_CipherFreeCtx(ctx);
    BSL_ERR_DeInit();
    return ret;
}

非对称加解密​

非对称加解密功能基于非对称算法提供了的加解密能力，如下以SM2加解密流程为例，给出了非对称加解密的示例代码，供适配参考。

示例代码​

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "crypt_eal_pkey.h" // 非对称加解密接口头文件
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"    // 算法id列表
#include "crypt_errno.h"    // 错误码列表
#include "crypt_eal_rand.h" // 随机数头文件
#include "crypt_types.h"

void *StdMalloc(uint32_t len) {
    return malloc((uint32_t)len);
}
void PrintLastError(void) {
    const char *file = NULL;
    uint32_t line = 0;
    BSL_ERR_GetLastErrorFileLine(&file, &line); // 获取错误发生的文件名和行数
    printf("failed at file %s at line %d\n", file, line);
}

BSL_SAL_MemCallback cb = {StdMalloc, free}; // 注册的内存分配接口

int main(void) {
    int32_t ret;
    BSL_ERR_Init(); // 初始化错误码模块
    // 调用算法API接口之前需要调用BSL_SAL_RegMemCallback函数注册malloc和free函数。该步骤仅需执行一次
    // 如果未注册并且默认能力没有被裁剪,使用默认linux实现
    BSL_SAL_RegMemCallback(&cb);
    CRYPT_EAL_PkeyCtx *pkey = NULL;
    pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
    if (pkey == NULL) {
        PrintLastError();
        goto exit;
    }

    // 初始化随机数
    ret = CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_RandInit: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 生成密钥对
    ret = CRYPT_EAL_PkeyGen(pkey);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_PkeyGen: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 待加密数据
    char *data = "test enc data";
    uint32_t dataLen = 12;
    uint8_t ecrypt[125] = {0};
    uint32_t ecryptLen = 125;
    uint8_t dcrypt[125] = {0};
    uint32_t dcryptLen = 125;
    // 加密
    ret = CRYPT_EAL_PkeyEncrypt(pkey, data, dataLen, ecrypt, &ecryptLen);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_PkeyEncrypt: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 解密
    ret = CRYPT_EAL_PkeyDecrypt(pkey, ecrypt, ecryptLen, dcrypt, &dcryptLen);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_PkeyDecrypt: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    if (memcmp(dcrypt, data, dataLen) == 0) {
        printf("encrypt and decrypt success\n");
    } else {
        ret = -1;
    }
exit:
    // 释放上下文内存。
    CRYPT_EAL_PkeyFreeCtx(pkey);
    CRYPT_EAL_RandDeinit();
    BSL_ERR_DeInit();
    return ret;
}

签名验证示例

算法类型​

签名验证功能基于非对称算法提供了的签名验证能力，如下以SM2签名验证为例，给出了签名验证的示例代码，供适配参考。

示例代码​

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "crypt_eal_pkey.h" // 签名验签头文件
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"    // 算法id列表
#include "crypt_errno.h"    // 错误码列表
#include "crypt_eal_rand.h" // 随机数头文件

void *StdMalloc(uint32_t len) {
    return malloc((size_t)len);
}

void PrintLastError(void) {
    const char *file = NULL;
    uint32_t line = 0;
    BSL_ERR_GetLastErrorFileLine(&file, &line); // 获取错误发生的文件名和行数
    printf("failed at file %s at line %d\n", file, line);
}
BSL_SAL_MemCallback cb = {StdMalloc, free}; // 注册的内存分配接口

int main(void)
{
    int ret;
    uint8_t userId[32] = {0};
    uint8_t key[32] = {0}; // 此处密钥仅作示例
    uint8_t msg[32] = {0};
    uint8_t signBuf[100] = {0};
    uint32_t signLen = sizeof(signBuf);
    CRYPT_EAL_PkeyPrv prv = {0};
    CRYPT_EAL_PkeyPub pub = {0};
    CRYPT_EAL_PkeyCtx *ctx = NULL;

    BSL_ERR_Init(); // 初始化错误码模块
    // 调用算法API接口之前需要调用BSL_SAL_RegMemCallback函数注册malloc和free函数。该步骤仅需执行一次
    // 如果未注册并且默认能力没有被裁剪,使用默认linux实现
    BSL_SAL_RegMemCallback(&cb);

    ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
    if (ctx == NULL) {
        goto exit;
    }

    // 设置用户Id
    ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId));
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 初始化随机数
    ret = CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 生成密钥对
    ret = CRYPT_EAL_PkeyGen(ctx);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 签名
    ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 验证
    ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    printf("pass \n");

exit:
    // 释放上下文内存
    CRYPT_EAL_PkeyFreeCtx(ctx);
    CRYPT_EAL_RandDeinit();
    BSL_ERR_DeInit();
    return ret;
}

密钥交换示例

算法类型​

密钥交换功能基于非对称算法提供了密钥交换能力，如下以ECDH为例，给出了密钥交换的示例代码，供适配参考。

示例代码​

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "crypt_types.h"
#include "crypt_eal_pkey.h" // 密钥交换头文件
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h" // 算法id列表
#include "crypt_errno.h" // 错误码列表
#include "crypt_eal_rand.h"

void *StdMalloc(uint32_t len) {
    return malloc((size_t)len);
}

void PrintLastError(void) {
    const char *file = NULL;
    uint32_t line = 0;
    BSL_ERR_GetLastErrorFileLine(&file, &line); // 获取错误发生的文件名和行数
    printf("failed at file %s at line %d\n", file, line);
}

BSL_SAL_MemCallback cb = {StdMalloc, free}; // 注册的内存分配接口

int main(void)
{
    int ret;

    uint8_t prikey[] =
        {0x7d, 0x7d, 0xc5, 0xf7, 0x1e, 0xb2, 0x9d, 0xda, 0xf8, 0x0d, 0x62, 0x14, 0x63, 0x2e, 0xea, 0xe0,
         0x3d, 0x90, 0x58, 0xaf, 0x1f, 0xb6, 0xd2, 0x2e, 0xd8, 0x0b, 0xad, 0xb6, 0x2b, 0xc1, 0xa5, 0x34};
    uint8_t pubkey[] =
        {0x04, 0x70, 0x0c, 0x48, 0xf7, 0x7f, 0x56, 0x58, 0x4c, 0x5c, 0xc6, 0x32, 0xca, 0x65, 0x64, 0x0d, 0xb9,
         0x1b, 0x6b, 0xac, 0xce, 0x3a, 0x4d, 0xf6, 0xb4, 0x2c, 0xe7, 0xcc, 0x83, 0x88, 0x33, 0xd2, 0x87,
         0xdb, 0x71, 0xe5, 0x09, 0xe3, 0xfd, 0x9b, 0x06, 0x0d, 0xdb, 0x20, 0xba, 0x5c, 0x51, 0xdc, 0xc5,
         0x94, 0x8d, 0x46, 0xfb, 0xf6, 0x40, 0xdf, 0xe0, 0x44, 0x17, 0x82, 0xca, 0xb8, 0x5f, 0xa4, 0xac};
    uint8_t resSharekey[] =
        {0x46, 0xfc, 0x62, 0x10, 0x64, 0x20, 0xff, 0x01, 0x2e, 0x54, 0xa4, 0x34, 0xfb, 0xdd, 0x2d, 0x25,
         0xcc, 0xc5, 0x85, 0x20, 0x60, 0x56, 0x1e, 0x68, 0x04, 0x0d, 0xd7, 0x77, 0x89, 0x97, 0xbd, 0x7b};

    CRYPT_EAL_PkeyPrv prvKey = {0};
    CRYPT_EAL_PkeyPub pubKey = {0};
    uint32_t shareLen;
    uint8_t *shareKey;
    CRYPT_EAL_PkeyCtx *prvCtx = NULL;
    CRYPT_EAL_PkeyCtx *pubCtx = NULL;
    CRYPT_PKEY_ParaId id = CRYPT_ECC_NISTP256;

    BSL_ERR_Init(); // 初始化错误码模块
    // 调用算法API接口之前需要调用BSL_SAL_RegMemCallback函数注册malloc和free函数。该步骤仅需执行一次
    // 如果未注册并且默认能力没有被裁剪,使用默认linux实现
    BSL_SAL_RegMemCallback(&cb);

    prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
    pubCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
    if (prvCtx == NULL || pubCtx == NULL) {
        goto exit;
    }

    // 设置曲线参数
    ret = CRYPT_EAL_PkeySetParaById(prvCtx, id);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 设置一端的私钥
    prvKey.id = CRYPT_PKEY_ECDH;
    prvKey.key.eccPrv.len = sizeof(prikey);
    prvKey.key.eccPrv.data = prikey;
    ret = CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 设置曲线参数
    ret = CRYPT_EAL_PkeySetParaById(pubCtx, id);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 设置另一端的公钥
    pubKey.id = CRYPT_PKEY_ECDH;
    pubKey.key.eccPub.len = sizeof(pubkey);
    pubKey.key.eccPub.data = pubkey;
    ret = CRYPT_EAL_PkeySetPub(pubCtx, &pubKey);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 共享密钥只涉及X轴, 这里返回点不压缩编码需要的长度
    shareLen = CRYPT_EAL_PkeyGetKeyLen(prvCtx) / 2;
    shareKey = (uint8_t *)BSL_SAL_Malloc(shareLen);
    if (shareKey == NULL) {
        ret = CRYPT_MEM_ALLOC_FAIL;
        PrintLastError();
        goto exit;
    }

    // 初始化随机数
    ret = CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_RandInit: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 计算共享密钥
    ret = CRYPT_EAL_PkeyComputeShareKey(prvCtx, pubCtx, shareKey, &shareLen);
    if (ret != CRYPT_SUCCESS) {
        printf("error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 和预期对比
    if (shareLen != sizeof(resSharekey) || memcmp(shareKey, resSharekey, shareLen) != 0) {
        printf("failed to compare test results\n");
        ret = -1;
        goto exit;
    }

    printf("pass \n");

exit:
    // 释放上下文内存。
    CRYPT_EAL_RandDeinit();
    CRYPT_EAL_PkeyFreeCtx(prvCtx);
    CRYPT_EAL_PkeyFreeCtx(pubCtx);
    BSL_SAL_Free(shareKey);
    BSL_ERR_DeInit();
    return 0;
}

密钥派生示例

算法类型​

提供了PBKDF2、HKDF、SCRYPT和KDFTLS12密钥派生能力，如下以PBKDF2密钥派生算法为例，给出了密钥派生的示例代码，供适配参考。

示例代码​

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "crypt_errno.h" // 错误码列表
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"   // 算法id列表
#include "crypt_eal_kdf.h" // 密钥派生接口头文件

void *StdMalloc(uint32_t len) {
    return malloc((size_t)len);
}

void PrintLastError(void) {
    const char *file = NULL;
    uint32_t line = 0;
    BSL_ERR_GetLastErrorFileLine(&file, &line);
    printf("failed at file %s at line %d\n", file, line);
}

BSL_SAL_MemCallback cb = {StdMalloc, free};

int main(void)
{
    int32_t ret;
    uint8_t key[] = {0x50, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64};
    uint8_t salt[] = {0x4e, 0x61, 0x43, 0x6c};
    uint32_t iterations = 80000;
    uint8_t result[] = {
        0x4d, 0xdc, 0xd8, 0xf6, 0x0b, 0x98, 0xbe, 0x21,
        0x83, 0x0c, 0xee, 0x5e, 0xf2, 0x27, 0x01, 0xf9,
        0x64, 0x1a, 0x44, 0x18, 0xd0, 0x4c, 0x04, 0x14,
        0xae, 0xff, 0x08, 0x87, 0x6b, 0x34, 0xab, 0x56,
        0xa1, 0xd4, 0x25, 0xa1, 0x22, 0x58, 0x33, 0x54,
        0x9a, 0xdb, 0x84, 0x1b, 0x51, 0xc9, 0xb3, 0x17,
        0x6a, 0x27, 0x2b, 0xde, 0xbb, 0xa1, 0xd0, 0x78,
        0x47, 0x8f, 0x62, 0xb3, 0x97, 0xf3, 0x3c, 0x8d};

    uint8_t out[sizeof(result)] = {0};
    uint32_t outLen = sizeof(result);

    // 初始化错误码模块
    BSL_ERR_Init();

    // 调用算法API接口之前需要调用BSL_SAL_RegMemCallback函数注册malloc和free函数。该步骤仅需执行一次
    // 如果未注册并且默认能力没有被裁剪,使用默认linux实现
    BSL_SAL_RegMemCallback(&cb);

    ret = CRYPT_EAL_Pbkdf2(CRYPT_MAC_HMAC_SHA256, key, sizeof(key), salt, sizeof(salt), iterations, out, outLen);
    if (ret != CRYPT_SUCCESS) {
        printf("pbkdf2 error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }
    if (memcmp(out, result, sizeof(result)) != 0) {
        printf("failed to compare test results\n");
        ret = -1;
        goto exit;
    }
    printf("pass \n");
exit:
    BSL_ERR_DeInit();
    return ret;
}

随机数生成示例

算法类型​

提供了DRBG-SHA、DRBG-HMAC和DRBG-CTR随机数算法，其接口类型分为两类，全局随机数接口和多实例随机数接口。

/* 
*  全局随机数初始化和去初始化接口
*  初始化接口的seedMeth参数是熵源回调，seedCtx是用户回调的上下文，
*  用户可以设置自己的熵源的实现。如果不设置，就使用系统默认熵源，
*  当前支持从 linux 的 /dev/random 获取熵 
*/
int32_t CRYPT_EAL_RandInit(CRYPT_RAND_AlgId id, CRYPT_RandSeedMethod *seedMeth, void *seedCtx, const uint8_t *pers, uint32_t persLen);
void CRYPT_EAL_RandDeinit(void);

/* 初始化之后，用户就可以调用如下接口获取伪随机数和补充熵源 */
int32_t CRYPT_EAL_Randbytes(uint8_t *byte, uint32_t len);
int32_t CRYPT_EAL_RandSeed(void);

/* 多实例接口对比全局DRBG接口的主要区别就是将DRBG的上下文返回给用户，
 * 支持用户创建多个DRBG上下文，不同上下文在熵源设置和内部状态变化之间互不干扰 。*/
CRYPT_EAL_RndCtx *CRYPT_EAL_DrbgInit(CRYPT_RAND_AlgId id, CRYPT_RandSeedMethod *seedMeth, void *seedCtx, const uint8_t *pers, uint32_t persLen);
void CRYPT_EAL_DrbgDeinit(CRYPT_EAL_RndCtx *ctx);

如下以DRBG-SHA算法为例，给出了随机数算法的示例代码，供适配参考。

示例代码​

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "crypt_types.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"    // 算法id列表
#include "crypt_errno.h"    // 错误码列表
#include "crypt_eal_rand.h" // 随机数头文件

void *StdMalloc(uint32_t len) {
    return malloc((size_t)len);
}

void PrintLastError(void) {
    const char *file = NULL;
    uint32_t line = 0;
    BSL_ERR_GetLastErrorFileLine(&file, &line); // 获取错误发生的文件名和行数
    printf("failed at file %s at line %d\n", file, line);
}

BSL_SAL_MemCallback cb = {StdMalloc, free}; // 注册的内存分配接口

int main(void)
{
    int ret;
    uint8_t output[100] = {0};
    uint32_t len = 100;

    // 调用算法API接口之前需要调用BSL_SAL_RegMemCallback函数注册malloc和free函数, 该步骤仅需执行一次。
    // 如果未注册并且默认能力没有被裁剪,使用默认linux实现
    BSL_SAL_RegMemCallback(&cb);

    BSL_ERR_Init(); // 初始化错误模块

    // 初始化全局随机数, 使用linux的/dev/random默认熵源
    ret = CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_RandInit: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 获得len长度的随机数序列
    ret = CRYPT_EAL_Randbytes(output, len);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_Randbytes: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    printf("random value is: "); // 输出随机数
    for (uint32_t i = 0; i < len; i++) {
        printf("%02x", output[i]);
    }
    printf("\n");

    // 重播种
    ret = CRYPT_EAL_RandSeed();
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_RandSeed: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    // 获得len长度的随机数序列
    ret = CRYPT_EAL_Randbytes(output, len);
    if (ret != CRYPT_SUCCESS) {
        printf("CRYPT_EAL_Randbytes: error code is %x\n", ret);
        PrintLastError();
        goto exit;
    }

    printf("random value is: "); // 输出随机数
    for (uint32_t i = 0; i < len; i++) {
        printf("%02x", output[i]);
    }
    printf("\n");

exit:
    // 释放上下文内存。
    CRYPT_EAL_RandDeinit();
    BSL_ERR_DeInit();
    return 0;
}

openHiTLS

Copyright © 2023 openHiTLS Project

欢迎关注openHiTLS微信公众号