OpenHarmony解读之设备认证：服务端处理PAKE协议End请求过程（2）

📌往期推文全新看点（文中附带最新·鸿蒙全栈学习笔记）

①📖 鸿蒙应用开发与鸿蒙系统开发哪个更有前景？

②📖嵌入式开发适不适合做鸿蒙南向开发？看完这篇你就了解了~

③📖 对于大前端开发来说，转鸿蒙开发究竟是福还是祸？

④📖 鸿蒙岗位需求突增！移动端、PC端、IoT到底该怎么选？

⑤📖 记录一场鸿蒙开发岗位面试经历~

⑥📖 持续更新中……

---

一、概述

在上一篇博客中提到，服务端处理PAKE协议End请求过程，作出了end响应，因此，本文将介绍客户端接收到end响应之后的处理过程。

二、源码分析

这一模块的源码位于：/base/security/deviceauth。

1. 首先执行parse_pake_server_confirm函数解析响应消息。

/*
函数功能：解析服务端confirm消息负载
函数参数：
    payload：消息负载
    data_type：数据类型
函数返回值：
    返回pake_end_response_data结构的confirm数据
*/
void *parse_pake_server_confirm(const char *payload, enum json_object_data_type data_type)
{
    struct pake_end_response_data *pake_server_confirm =
        (struct pake_end_response_data *)MALLOC(sizeof(struct pake_end_response_data));//申请pake_end_response_data结构体空间
    if (pake_server_confirm == NULL) {
        return NULL;
    }
    (void)memset_s(pake_server_confirm, sizeof(*pake_server_confirm), 0, sizeof(*pake_server_confirm));//清空该空间
    json_handle obj = parse_payload(payload, data_type);//如果消息负载为json格式的字符串，则将json格式的数据解析成cjson结构体对象
    if (obj == NULL) {
        LOGE("Parse Pake Server Confirm parse payload failed");
        goto error;
    }
    /* kcfData */
    int32_t result = byte_convert(obj, FIELD_KCF_DATA, pake_server_confirm->kcf_data.hmac,
                                  (uint32_t *)&pake_server_confirm->kcf_data.length, HC_HMAC_LEN);//获取kcfData，字节转换函数，将十六进制字符串转换为byte数组
    if (result != HC_OK) {
        LOGE("Parse Auth ACK Request Data failed, field is null in addId");
        goto error;
    }
    free_payload(obj, data_type);
    return (void *)pake_server_confirm;//返回最终解析结果
error:
    free_payload(obj, data_type);
    FREE(pake_server_confirm);
    return NULL;
}

2. receive_pake_end_response函数，接收pake end响应。

/*
函数功能：接收end响应消息
函数参数：
    pake_client：pake客户端对象
    receive：接收的消息数据
函数返回值：
    成功：0
    失败：error num
*/
int32_t receive_pake_end_response(struct pake_client *pake_client, struct message *receive)
{
    check_ptr_return_val(pake_client, HC_INPUT_ERROR);//检查参数有效性
    check_ptr_return_val(receive, HC_INPUT_ERROR);
    DBG_OUT("Receive pake end response message object %u success", pake_client_sn(pake_client));
    struct pake_end_response_data *receive_data = (struct pake_end_response_data *)receive->payload;//用pake_end_response_data结构体变量接收该消息负载部分
    int32_t ret = receive_end_response(pake_client, receive_data);
    if (ret != HC_OK) {
        LOGE("Called receive_end_response failed, error code is %d", ret);
        receive->msg_code = INFORM_MESSAGE;
    } else {
        DBG_OUT("Called receive_end_response success");
        receive->msg_code = PAKE_SERVER_CONFIRM_RESPONSE;//设置消息码为PAKE_SERVER_CONFIRM_RESPONSE
        receive->payload = receive_data;//赋值消息负载
    }
    return ret;
}

3. receive_end_response函数。

/*
函数功能：接收end响应消息
函数参数：
    handle：句柄，可用相关结构体获取
    receive_data：接收到的消息数据
函数返回值：
    成功：0
    失败：error num
*/
int32_t receive_end_response(void *handle, void *receive_data)
{
    check_ptr_return_val(handle, HC_INPUT_ERROR);//检查参数有效性
    check_ptr_return_val(receive_data, HC_INPUT_ERROR);
    struct key_agreement_client *client = (struct key_agreement_client *)handle;//用密钥协商客户端接收该对象
    struct key_agreement_protocol *base = &client->protocol_base_info;//定义密钥协商协议基础信息
    DBG_OUT("Object %u begin receive end response data", base->sn);
    if (is_state_error(client, RECEIVE_END_RESPONSE)) {//判断协议状态和协议动作是否对应错误
        LOGE("Object %u state error", base->sn);
        return PROTOCOL_STATE_ERROR;
    }
    struct client_virtual_func_group *funcs = &client->package_funcs;//客户端虚函数组，定义打包函数
    int32_t ret = funcs->parse_end_response_data(handle, receive_data);//解析end响应数据
    if (ret != HC_OK) {
        set_state(base, PROTOCOL_ERROR);
        LOGE("Object %u parse end response data failed, error code is %d", base->sn, ret);
        return ret;
    }
    set_state(base, PROTOCOL_FINISH);//设置协议状态为PROTOCOL_FINISH
    set_last_time_sec(base);//设置上一次的时间
    DBG_OUT("Object %u receive end response data success", base->sn);
    return HC_OK;
}

4. parse_end_response_data函数，进一步解析end响应消息：验证对端的proof数据然后生成本端服务密钥service_key。

/*
函数功能：解析end响应数据
函数参数：
    handle：pake客户端对象
    data：接收的消息数据
函数返回值：
    成功：0
    失败：error num
*/
static int32_t parse_end_response_data(void *handle, void *data)
{
    struct pake_client *pake_client = (struct pake_client *)handle;//接收pake客户端对象
    struct pake_end_response_data *receive = (struct pake_end_response_data *)data;//pake_end_response_data结构体变量接收数据负载
    if (verify_proof_is_ok(pake_client, &receive->kcf_data) != true) {//验证对端proof是否ok
        LOGE("Object %u verify proof failed", pake_client_sn(pake_client));
        return HC_VERIFY_PROOF_FAILED;
    }
    generate_output_key(pake_client);//生成客户端output密钥
    return HC_OK;
}

5. verify_proof_is_ok函数，验证对端proof是否正确。

/*
函数功能：验证服务端发来的proof是否ok
函数参数：
    pake_client：pake客户端对象
    kcf_data：来自服务端的proof数据
函数返回值：
    正确：true
    错误：false
详细：
    本函数的目的在于根据对端epk和challenge值+本端esk和challenge值生成一个验证proof，然后与对端发来的proof作比较，
如果相等，则返回true，否则返回false。
*/
static bool verify_proof_is_ok(struct pake_client *pake_client, struct hmac *kcf_data)
{
    struct uint8_buff challenge = {.size = CHALLENGE_BUFF_LENGTH + CHALLENGE_BUFF_LENGTH};//定义challenge缓冲区
    challenge.val = (uint8_t *)MALLOC(challenge.size);//为该缓冲区申请空间
    if (challenge.val == NULL) {
        LOGE("Object %u MALLOC verify proof buffer failed", pake_client_sn(pake_client));
        return false;
    }
    (void)memcpy_s(challenge.val, challenge.size, pake_client->peer_challenge.challenge, CHALLENGE_BUFF_LENGTH);//将对端challenge值拷贝到该challenge buf中
    challenge.length = CHALLENGE_BUFF_LENGTH;
    (void)memcpy_s(challenge.val + challenge.length, challenge.size - challenge.length,
                   pake_client->self_challenge.challenge, CHALLENGE_BUFF_LENGTH);//将本端challenge值拷贝到该challenge buf中
    challenge.length += CHALLENGE_BUFF_LENGTH;
    //这里的挑战值在缓冲区的顺序为：{服务端challenge，客户端challenge}
    struct hmac verify_proof = { 0, {0} };//定义验证proof
    int32_t ret = compute_hmac((struct var_buffer *)&pake_client->hmac_key, &challenge, &verify_proof);//根据hmac密钥和双端challenge值计算HMAC值保存在验证verify_proof中
    FREE(challenge.val);
    challenge.val = NULL;
    if (ret != HC_OK) {
        LOGE("Object %u verify proof hmac failed, error code is %d", pake_client_sn(pake_client), ret);
        return false;
    }
    ret = memcmp(&verify_proof, kcf_data, sizeof(verify_proof));//比较本端生成的verify_proof与对端发过来的proof数据kcf_data是否相等
    LOGI("Object %u verify proof hmac result is %d", pake_client_sn(pake_client), ret);
    return (ret == 0);
}

6. generate_output_key函数，生成output密钥，实际上是生成客户端service key。

//生成客户端output密钥
static void generate_output_key(struct pake_client *pake_client)
{
    DBG_OUT("pake client generate output key");
    int32_t ret = compute_hkdf((struct var_buffer *)&pake_client->session_key, &pake_client->salt,
                               HICHAIN_RETURN_KEY, pake_client->key_length,
                               (struct var_buffer *)&pake_client->service_key);//将客户端会话密钥作为种子，加上客户端salt值，生成hkdf作为客户端的服务密钥service_key
    if (ret != HC_OK) {
        LOGE("Object %u generate output key failed, error code is %d", pake_client_sn(pake_client), ret);
        return;
    } else {
        DBG_OUT("Pake client generate output key success");
        return;
    }
}

三、小结

客户端收到end响应之后，同样根据服务端epk、双端challenge、salt、客户端esk等信息生成一个验证证据verify_proof，然后与服务端发送来的proof进行对比，如果相同，则根据客户端session_key和salt值等信息基于hkdf算法生成客户端的service_key。至此，pake协议的整个流程结束。