security_huks/framework/huks_standard/common/hks_check_paramset解读(二)

知识总结

这里出现了一种新的加密函数PBKDF2
它的基本原理是通过一个伪随机函数（例如HMAC函数），把明文和一个SALT值作为输入参数，然后重复进行运算，并最终产生密钥。
如果重复的次数足够大，破解的成本就会变得很高。那么信息也就更加安全

总结概述

封装了对各类型参数的检查函数
对应了文件名字paramset的check——对paraset中的类型函数进行检查
分为这么几类：
1.genKey
2.importKey
3.SignVerify
4.agreeKey
5.LocalKey
6.DeriveKey
上一篇解读的链接：
hks_check_paramset解读一

代码解读

1.Pbkdf2算法相关

1. 参数检查函数
   利用CheckBlob 检查saltParam->blob
   

2.封装函数对GenKey参数的检查

在函数体中对变量加void，防止参数未传时，编译器报warning

初始化params并调用CoreCheckGenKeyParams进行核心参数的检查

3.对于importKey参数检查函数

函数流程：调用CoreCheckGenKeyParams根据全局存储的tag对GenKey进行参数检查---->genKey参数检查无误后调用CheckAndGetAlgorithm获取importKeyAlg---->先检查其keySize---->再对其中的可选参数进行检查并打印相应的错误信息

4.对于SignVerify参数的检查

流程：获取signAlg---->获取input参数---->根据alg检查sign参数---->检查签名

5.agreeKey的size检查函数

//agreeSize检查
int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *privateKey,
    const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey, bool isLocalCheck)
{
    uint32_t alg;
    int32_t ret;

    //本地检查
    if (isLocalCheck) {
        //检查带出的参数是否符合期望并将algParam.uint32Param赋给*alg
        ret = CheckAndGetAlgorithm(paramSet, g_agreeAlgLocal, HKS_ARRAY_SIZE(g_agreeAlgLocal), &alg);
    } else {
        ret = CheckAndGetAlgorithm(paramSet, g_agreeAlg, HKS_ARRAY_SIZE(g_agreeAlg), &alg);
    }
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("check alg failed");
        return ret;
    }

    uint32_t keySize = 0;
    //密钥大小的比较
    if (isLocalCheck) {
        if ((privateKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256)) ||
            (peerPublicKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256))) {
            return HKS_ERROR_INVALID_KEY_SIZE;
        }
        keySize = privateKey->size * HKS_BITS_PER_BYTE;
    } else {
        ret = HksGetKeySize(alg, privateKey, &keySize);
        if (ret != HKS_SUCCESS) {
            HKS_LOG_E("get key size failed");
            return ret;
        }
    }
    //获取size
    uint32_t size = keySize / HKS_BITS_PER_BYTE + keySize % HKS_BITS_PER_BYTE;
    //做size检查
    if (agreedKey->size < size) {
        HKS_LOG_E("agreeKey buffer too small, size %u", agreedKey->size);
        return HKS_ERROR_BUFFER_TOO_SMALL;
    }

    return HKS_SUCCESS;
}

6.对加密参数和数据封装检查函数

HksCoreCheckCipherParams
流程：调用CheckAndGetAlgorithm获取加密算法参数---->根据获取的alg得到input参数---->获取密钥size---->调用CheckCipherParamsByAlg对三部分参数进行检查---->调用HksCheckCihperData对输入输出数据进行size规范检查

//根据g_cipherAlg得到算法参数，再根据alg获取输入参数，并进行参数和数据检查
int32_t HksCoreCheckCipherParams(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet,
    const struct HksBlob *inData, const struct HksBlob *outData)
{
    uint32_t alg;
    int32_t ret = CheckAndGetAlgorithm(paramSet, g_cipherAlg, HKS_ARRAY_SIZE(g_cipherAlg), &alg);
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("check alg failed");
        return ret;
    }

    struct ParamsValues params;
    (void)memset_s(&params, sizeof(params), 0, sizeof(params));

    //获取input参数
    ret = HksGetInputParmasByAlg(alg, HKS_CHECK_TYPE_USE_KEY, paramSet, &params);
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("cipher get input params failed, ret = %d", ret);
        return ret;
    }

    if (alg == HKS_ALG_RSA) {
        ret = HksGetKeySize(alg, key, &params.keyLen.value);
        if (ret != HKS_SUCCESS) {
            HKS_LOG_E("rsa cipher get key size failed");
            return ret;
        }
    }

    ret = CheckCipherParamsByAlg(cmdId, alg, paramSet, &params);
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("cipher check params failed, ret = %d", ret);
        return ret;
    }

    ret = HksCheckCihperData(cmdId, alg, &params, inData, outData);
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("cipher check input or output data failed, ret = %d", ret);
    }

    return ret;
}

7.本地加密参数的检查

与6相似多了一步对于keySize的判断

8.对于DeriveKey参数的检查函数

HksCoreCheckDeriveKeyParams
流程：根据传入的参数isLocalCheck进行local和非local的算法参数获取---->获取purpose参数---->purpose是derive-purpose时则检查摘要---->当定义了HKS_SUPPORT_KDF_PBKDF2，算法为PBKDF2则调用CheckPbkdf2DeriveKeyParams对该加密算法参数进行单独的检查

//对于deriveKey参数的检查core
int32_t HksCoreCheckDeriveKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *mainKey,
    const struct HksBlob *derivedKey, bool isLocalCheck)
{
    (void)mainKey;
    (void)derivedKey;
    uint32_t alg;
    int32_t ret;
    //是否为本地
    if (isLocalCheck) {
        ret = CheckAndGetAlgorithm(paramSet, g_deriveAlgLocal, HKS_ARRAY_SIZE(g_deriveAlgLocal), &alg);
    } else {
        ret = CheckAndGetAlgorithm(paramSet, g_deriveAlg, HKS_ARRAY_SIZE(g_deriveAlg), &alg);
    }
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("check alg failed");
        return ret;
    }
    //获取purpose参数
    struct HksParam *purposeParam = NULL;
    ret = HksGetParam(paramSet, HKS_TAG_PURPOSE, &purposeParam);
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("get param get 0x%x failed", HKS_TAG_PURPOSE);
        return HKS_ERROR_CHECK_GET_PURPOSE_FAIL;
    }
    //purpose是否为derive
    if (purposeParam->uint32Param != HKS_KEY_PURPOSE_DERIVE) {
        return HKS_ERROR_INVALID_PURPOSE;
    }

    /* according to RFC5869, HKDF no need check salt and info */
    //则进行摘要的检查
    uint32_t digest;
    ret = CheckAndGetDigest(paramSet, g_digest, HKS_ARRAY_SIZE(g_digest), &digest);
    if (ret != HKS_SUCCESS) {
        HKS_LOG_E("check digest failed");
        return ret;
    }

#ifdef HKS_SUPPORT_KDF_PBKDF2
    if (alg == HKS_ALG_PBKDF2) {
        return CheckPbkdf2DeriveKeyParams(paramSet);
    }
#endif

    return HKS_SUCCESS;
}

9.MAC相关检查

1. 对于MAC生成的摘要进行规范检查(size)
   
2. 检查是否为MAC_PURPOSE函数
   
3. 封装对于purpose和摘要的检查函数