OpenHarmony解读之设备认证：pake协议-服务端响应pake end请求

最新推荐文章于 2023-09-10 21:37:27 发布
最新推荐文章于 2023-09-10 21:37:27 发布
阅读量381 收藏
点赞数
分类专栏： OpenHarmony源码分析 文章标签： harmonyos 华为 分布式 tcp/ip 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46669761/article/details/125035599
版权

一、概述

针对客户端发起的end请求，服务端应作出对应的响应，本文重点介绍服务端解析end请求的过程及构造响应消息的过程。

二、源码分析

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

1. 首先解析收到的消息数据：parse_pake_client_confirm函数。
/*
函数功能：解析pake客户端confirm消息
函数参数：
    payload：消息负载部分
    data_type：数据类型
函数返回值：
    返回pake_end_request_data结构的confirm消息
*/
void *parse_pake_client_confirm(const char *payload, enum json_object_data_type data_type)
{
    struct pake_end_request_data *pake_client_confirm =
        (struct pake_end_request_data *)MALLOC(sizeof(struct pake_end_request_data));//申请pake_end_request_data结构体空间
    if (pake_client_confirm == NULL) {
        return NULL;
    }
    (void)memset_s(pake_client_confirm, sizeof(*pake_client_confirm), 0, sizeof(*pake_client_confirm));//清空该空间
    json_pobject obj = parse_payload(payload, data_type);//如果消息负载为json格式的字符串，则将json格式的数据解析成cjson结构体对象
    if (obj == NULL) {
        LOGE("Parse Pake Client Confirm parse payload failed");
        goto error;
    }
    /* challenge */
    int32_t result = byte_convert(obj, FIELD_CHALLENGE, pake_client_confirm->challenge.challenge,
                                  &pake_client_confirm->challenge.length, CHALLENGE_BUFF_LENGTH);//获取challenge值，字节转换函数，将十六进制字符串转换为byte数组
    if (result != HC_OK) {
        LOGE("Parse Pake Client Confirm failed, field is null in challenge");
        goto error;
    }
    /* kcfData */
    result = byte_convert(obj, FIELD_KCF_DATA, pake_client_confirm->kcf_data.hmac,
                          &pake_client_confirm->kcf_data.length, HC_HMAC_LEN);//获取kcfData，字节转换函数，将十六进制字符串转换为byte数组
    if (result != HC_OK) {
        LOGE("Parse Pake Client Confirm failed, field is null in kcfData");
        goto error;
    }
    /* epk */
    result = byte_convert(obj, FIELD_EPK, pake_client_confirm->epk.epk,
                          &pake_client_confirm->epk.length, PAKE_EPK_LENGTH);//获取epk，字节转换函数，将十六进制字符串转换为byte数组
    if (result != HC_OK) {
        LOGE("Parse Pake Client Confirm failed, field is null in epk");
        goto error;
    }
    free_payload(obj, data_type);
    return (void *)pake_client_confirm;
error:
    free_payload(obj, data_type);
    FREE(pake_client_confirm);
    return NULL;
}
2. 然后调用函数proc_pake_request_message处理数据。
/*
函数功能：处理pake请求消息
函数参数：
    handle：hichain实例
    nav：消息头分析导航
    receive：接收的消息
    send：待发送消息地址
函数返回值：
    成功：0
    失败：error
*/
static int32_t proc_pake_request_message(struct hichain *handle, struct header_analysis *nav,
    struct message *receive, struct message *send)
#if !(defined(_CUT_PAKE_) || defined(_CUT_PAKE_SERVER_))
{
    DBG_OUT("Object %u proc pake %d request message", pake_server_sn(handle->pake_server), nav->msg_type);
    int32_t ret;

    if (nav->msg_type == PAKE_START_MSG) {//如果是start请求
        ret = send_pake_start_response(handle->pake_server, receive, send);//针对start请求构造发送响应消息
    } else if (nav->msg_type == PAKE_END_MSG) {//如果是end请求
        ret = send_pake_end_response(handle->pake_server, receive, send);//针对end请求发送响应消息
        if (ret == HC_OK) {
            handle->cb.set_session_key(&handle->identity, &handle->pake_server->service_key);//设置会话密钥为service_key
            (void)memset_s(handle->pake_server->service_key.session_key, HC_SESSION_KEY_LEN, 0, HC_SESSION_KEY_LEN);//清空会话密钥空间
        }
    } else {
        return HC_UNKNOW_MESSAGE;
    }
    return ret;
}
3. 根据消息类型为PAKE_END_MSG，应执行send_pake_end_response函数，针对end请求发送响应消息。
/*
函数功能：准备待发送的end响应数据
函数参数：
    pake_server：pake服务端对象
    receive：接收到的消息
    send：待发送的数据缓冲区地址
函数返回值：
    成功：0
    失败：error num
*/
int32_t send_pake_end_response(struct pake_server *pake_server, struct message *receive, struct message *send)
{
    check_ptr_return_val(pake_server, HC_INPUT_ERROR);//检查参数有效性
    check_ptr_return_val(receive, HC_INPUT_ERROR);
    check_ptr_return_val(send, HC_INPUT_ERROR);
    DBG_OUT("Receive pake end request message object %u success", pake_server_sn(pake_server));
    struct pake_end_request_data *receive_data = receive->payload;//用pake_end_request_data结构接收消息负载
    struct pake_end_response_data *send_data =
        (struct pake_end_response_data *)MALLOC(sizeof(struct pake_end_response_data));//申请待发送的数据缓冲结构pake_end_response_data空间

    if (send_data == NULL) {
        LOGE("Malloc struct pake_end_response_data failed");
        send->msg_code = INFORM_MESSAGE;
        return HC_MALLOC_FAILED;
    }
    (void)memset_s(send_data, sizeof(*send_data), 0, sizeof(*send_data));//清空该结构体空间
    int32_t ret = send_end_response(pake_server, receive_data, send_data);//构造end响应数据，保存到send_data结构体中
    if (ret != HC_OK) {//失败
        LOGE("Object %u called send_end_response failed, error code is %d", pake_server_sn(pake_server), ret);
        FREE(send_data);
        send_data = NULL;
        send->msg_code = INFORM_MESSAGE;
    } else {//成功
        LOGI("Object %u called send_end_response success", pake_server_sn(pake_server));
        send->msg_code = PAKE_SERVER_CONFIRM_RESPONSE;//设置消息码为：PAKE_SERVER_CONFIRM_RESPONSE
        send->payload = send_data//将准备好的消息数据负载赋值给待发送的消息send
    }
    return ret;
}
4. send_end_response函数，发送end响应消息，首先解析end请求数据，然后构造end响应消息。
/*
函数功能：发送end响应消息，首先解析end请求数据，然后构造end响应消息
函数参数：
    handle：句柄，可用相关结构体获取
    receive_data：接收的数据
    send_data：待发送数据地址
函数返回值：
    成功：0
    失败：error
*/
int32_t send_end_response(void *handle, void *receive_data, void *send_data)
{
    check_ptr_return_val(handle, HC_INPUT_ERROR);//检查参数有效性
    check_ptr_return_val(receive_data, HC_INPUT_ERROR);
    check_ptr_return_val(send_data, HC_INPUT_ERROR);
    struct key_agreement_server *server = handle;//以密钥协商服务端对象接收该对象
    struct key_agreement_protocol *base = &server->protocol_base_info;//赋值协议基础信息

    DBG_OUT("Object %u begin receive end request data and send end response data", base->sn);
    if (is_state_error(server, SEND_END_RESPONSE)) {//判断协议状态是否错误
        LOGE("Object %u state error", base->sn);
        return PROTOCOL_STATE_ERROR;
    }
    const struct server_virtual_func_group *funcs = &server->package_funcs;//赋值服务端打包函数
    int32_t ret = funcs->parse_end_request_data(handle, receive_data);//执行解析函数解析end请求数据
    if (ret != HC_OK) {//解析失败
        set_state(base, PROTOCOL_ERROR);
        LOGE("Object %u parse end request data failed, error code is %d", base->sn, ret);
        return ret;
    }
    ret = funcs->build_end_response_data(handle, send_data);//调用回调函数构造end响应消息
    if (ret != HC_OK) {
        set_state(base, PROTOCOL_ERROR);
        LOGE("Object %u build 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 request data send end response data succcess", base->sn);
    return HC_OK;
}
5. 在函数send_end_response中首先执行回调函数parse_end_request_data进一步解析end请求数据。
/*
函数功能：解析end请求数据
函数参数：
    handle：pake服务端对象
    receive_data：接收数的消息数据
函数返回值：
    成功：0
    失败：error num
*/
static int32_t parse_end_request_data(void *handle, void *receive_data)
{
    struct pake_server *pake_server = handle;//接收对象
    struct pake_end_request_data *data = receive_data;//接收数据

    DBG_OUT("Object %u begin parse PAKE end request data", pake_server_sn(pake_server));
    pake_server->peer_challenge = data->challenge;//赋值pake服务端对象的对端challenge值
    int32_t ret = generate_session_key(pake_server, &data->epk);//根据对端epk和本端esk生成服务端会话密钥保存在pake服务端对象中
    if (ret != HC_OK) {
        LOGE("Object %u generate session key failed", pake_server_sn(pake_server));
        return ret;
    }

    if (verify_proof_is_ok(pake_server, &data->kcf_data) != true) {//验证对端proof是否ok
        LOGE("Object %u verify proof failed", pake_server_sn(pake_server));
        return HC_VERIFY_PROOF_FAILED;
    }

    generate_output_key(pake_server);//生成服务端output密钥
    return HC_OK;
}

/*
函数功能：生成pake服务端会话密钥
函数参数：
    pake_server：pake服务端对象
    peer_epk：对端epk
函数返回值：
    成功：0
    失败：error num
*/
static int32_t generate_session_key(struct pake_server *pake_server, struct epk *peer_epk)
{
    struct pake_shared_secret shared_secret = { 0, {0} };//定义共享密钥
    uint32_t prime_len = (pake_server->prime_type == NUM_LEN_384) ?
        HC_BIG_PRIME_MAX_LEN_384 : HC_BIG_PRIME_MAX_LEN_256;//获取素数长度
    int32_t ret = cal_bignum_exp((struct var_buffer *)peer_epk, (struct var_buffer *)&pake_server->self_esk,
        prime_len, (struct big_num *)&shared_secret);//根据对端的epk和本端的esk计算大素数指数作为共享密钥shared_secret
    if (ret != HC_OK) {
        LOGE("Object %u generate shared secret failed, error code is %d", pake_server_sn(pake_server), ret);
        goto error;
    }

    struct hkdf hkdf = { 0, {0} };//hkdf派生密钥
    ret = compute_hkdf((struct var_buffer *)&shared_secret, &pake_server->salt,
        HICHAIN_SPEKE_SESSIONKEY_INFO, HC_HKDF_SECRET_LEN, (struct var_buffer *)&hkdf);//基于HKDF算法的密钥派生函数，根据密钥派生种子和salt值计算出派生密钥保存在secret中
    if (ret != HC_OK) {
        LOGE("Object %u generate hkdf failed, error code is %d", pake_server_sn(pake_server), ret);
        goto error;
    }

    (void)memcpy_s(pake_server->session_key.key, sizeof(pake_server->session_key.key),
                   hkdf.hkdf, PAKE_SESSION_KEY_LENGTH);//将计算出来的hkdf派生密钥拷贝给pake服务端的会话密钥
    (void)memcpy_s(pake_server->hmac_key.key, sizeof(pake_server->hmac_key.key),
                   hkdf.hkdf + PAKE_SESSION_KEY_LENGTH, PAKE_HMAC_KEY_LENGTH);//将计算出来的"hkdf派生密钥+会话密钥长度"拷贝给pake服务端的HMAC密钥
    pake_server->session_key.length = PAKE_SESSION_KEY_LENGTH;//会话密钥长度
    pake_server->hmac_key.length = PAKE_HMAC_KEY_LENGTH;//HMAC密钥长度
    return HC_OK;

error://错误处理
    pake_server->session_key.length = 0;
    pake_server->hmac_key.length = 0;
    return HC_GENERATE_SESSION_KEY_FAILED;
}
6. 在函数parse_end_request_data中执行verify_proof_is_ok函数验证对端proof是否正确。
/*
函数功能：验证客户端发来的proof是否ok
函数参数：
    pake_server：pake服务端对象
    kcf_data：来自客户端的proof数据
函数返回值：
    正确：true
    错误：false
详细：
    本函数的目的在于根据对端epk和challenge值+本端esk和challenge值生成一个验证proof，然后与对端发来的proof作比较，
如果相等，则返回true，否则返回false。
*/
static bool verify_proof_is_ok(struct pake_server *pake_server, 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_server_sn(pake_server));
        return false;
    }

    (void)memcpy_s(challenge.val, challenge.size, pake_server->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_server->self_challenge.challenge, CHALLENGE_BUFF_LENGTH);//将本端challenge值拷贝到该challenge buf中
    challenge.length += CHALLENGE_BUFF_LENGTH;
    struct hmac verify_proof = { 0, {0} };//定义验证proof
    //这里的挑战值在缓冲区的顺序为：{客户端challenge，服务端challenge}
    int32_t ret = compute_hmac((struct var_buffer *)&pake_server->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_server_sn(pake_server), 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_server_sn(pake_server), ret);

    return (ret == 0);
}
7. 在parse_end_request_data函数中执行generate_output_key函数生成服务端output密钥。
//生成服务端output密钥
static void generate_output_key(struct pake_server *pake_server)
{
    DBG_OUT("pake server generate output key");
    int32_t ret = compute_hkdf((struct var_buffer *)&pake_server->session_key, &pake_server->salt,
                               HICHAIN_RETURN_KEY, pake_server->key_length,
                               (struct var_buffer *)&pake_server->service_key);//将服务端会话密钥作为种子，加上服务端salt值，生成hkdf作为服务端的服务密钥service_key
    if (ret != HC_OK) {
        LOGE("Object %u generate output key failed, error code is %d", pake_server_sn(pake_server), ret);
    }
}
8.回到函数send_end_response中继续执行回调函数build_end_response_data，构造end响应数据。
/*
函数功能：构造end响应数据
函数参数：
    handle：pake服务端对象
    send_data：待发送的数据缓冲区
函数返回值：
    成功：0
    失败：error
*/
static int32_t build_end_response_data(void *handle, void *send_data)
{
    struct pake_server *pake_server = handle;//获取服务端对象
    struct pake_end_response_data *data = send_data;//用pake_end_response_data结构准备待发送的数据

    DBG_OUT("Object %u begin build PAKE end response data", pake_server_sn(pake_server));
    data->kcf_data = generate_proof(pake_server);//根据hmac密钥和双端challenge值生成一个HMAC值proof（服务端）
    if (data->kcf_data.length == 0) {//如果proof生成失败，则返回HC_GENERATE_PROOF_FAILED
        LOGE("Object %u generate proof failed", pake_server_sn(pake_server));
        return HC_GENERATE_PROOF_FAILED;
    }
    return HC_OK;
}
9. 在build_end_response_data函数中执行generate_proof函数根据hmac密钥和双端challenge值生成一个HMAC值proof（服务端）。
/*
函数功能：根据hmac密钥和双端challenge值生成一个HMAC值proof（服务端）
函数参数：
    pake_server：pake服务端对象
函数返回值：
    返回生成的proof值
*/
static struct hmac generate_proof(struct pake_server *pake_server)
{
    struct hmac proof = { 0, {0} };//定义并初始化proof
    struct uint8_buff challenge = {//定义一个challenge buf存放本端challenge值和对端challenge值
        .val = NULL,
        .length = 0,
        .size = CHALLENGE_BUFF_LENGTH + CHALLENGE_BUFF_LENGTH
    };

    challenge.val = (uint8_t *)MALLOC(challenge.size);//为该challenge缓冲区申请空间
    if (challenge.val == NULL) {
        LOGE("Object %u MALLOC generate proof buffer failed", pake_server_sn(pake_server));
        return proof;
    }

    (void)memcpy_s(challenge.val, challenge.size, pake_server->self_challenge.challenge, CHALLENGE_BUFF_LENGTH);//将本端challenge值拷贝到该challenge buf中
    challenge.length = CHALLENGE_BUFF_LENGTH;//赋值challenge长度
    (void)memcpy_s(challenge.val + challenge.length, challenge.size - challenge.length,
                   pake_server->peer_challenge.challenge, CHALLENGE_BUFF_LENGTH);//将对端challenge值拷贝到该challenge buf中
    challenge.length += CHALLENGE_BUFF_LENGTH;//加上challenge长度
    //这里的challenge值在缓冲区的顺序为：{服务端challenge，客户端challenge}
    int32_t ret = compute_hmac((struct var_buffer *)&pake_server->hmac_key, &challenge, &proof);//根据hmac密钥和双端challenge值计算HMAC值保存在proof中
    FREE(challenge.val);
    challenge.val = NULL;
    if (ret != HC_OK) {
        LOGE("Object %u generate proof hmac failed, error code is %d", pake_server_sn(pake_server), ret);
        proof.length = 0;
    }
    DBG_OUT("Object %u generate proof success", pake_server_sn(pake_server));
    return proof;
}
10. 最后回到receive_data函数中，执行build_send_data_by_struct函数构造通知消息，然后再build_send_data_by_struct函数中根据消息码选择对应构造消息函数，此处应是make_pake_server_confirm函数。
/*
函数功能：构造pake服务端confirm消息
函数参数：
    data：待发送数据
函数返回值：
    json格式的字符串
*/
char *make_pake_server_confirm(void *data)
{
    struct pake_end_response_data *pake_server_confirm = data;//pake_end_response_data结构接收数据
    /* kcfData */
    uint8_t *tmp_kcf_data_hex = raw_byte_to_hex_string(pake_server_confirm->kcf_data.hmac,
                                                       pake_server_confirm->kcf_data.length);//将kcfData值转换为十六进制格式的字符串
    if (tmp_kcf_data_hex == NULL) {
        return NULL;
    }
    char *ret_str = (char *)MALLOC(RET_STR_LENGTH);//申请2048字节的空间以存放待发送消息
    if (ret_str == NULL) {
        FREE(tmp_kcf_data_hex);
        return NULL;
    }
    (void)memset_s(ret_str, RET_STR_LENGTH, 0, RET_STR_LENGTH);//清空该地址空间
    if (snprintf_s(ret_str, RET_STR_LENGTH, RET_STR_LENGTH - 1, "{\"%s\":%d,\"%s\":{\"%s\":\"%s\"}}", FIELD_MESSAGE,
        PAKE_SERVER_CONFIRM_RESPONSE, FIELD_PAYLOAD, FIELD_KCF_DATA, tmp_kcf_data_hex) < 0) {
        LOGE("String generate failed");
        FREE(ret_str);
        ret_str = NULL;
    }//生成json格式的消息字符串
    FREE(tmp_kcf_data_hex);
    return ret_str;
}

三、小结

经过分析，服务端生成的响应消息的格式如下：

{
    "message":0x8002,						//消息码：PAKE_SERVER_CONFIRM_RESPONSE
    "payload":
    {
        "kcfData":"十六进制格式的字符串"    	//kcfData,用于身份认证，根据hmac密钥和双端challenge值生成的HMAC值
    }
}

服务端接收到来自客户端的challenge、epk等信息，根据这些信息及本端的challenge、salt、esk等信息生成验证认证证据verify_proof，然后与客户端发送来的proof进行对比，如果验证正确，则根据服务端session_key和salt值等信息基于hkdf算法生成服务端的service_key。然后服务端基于hmac_key和双端challenge（与客户端的存储顺序相反）根据HMAC算法生成服务端的proof保存在kcfData字段中回复给客户端。

xjingxuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通用可组合安全的匿名认证密钥交换协议 (2010年)
05-29
针对智能卡登录系统中远程身份认证和密钥交换问题，提出一种具有通用可组合安全的基于口令的匿名认证密钥交换协议--πpAKE・．该协议采用匿名技术进行登录认证及信息存储管理，使用Diffie- Hellman(DH)算法实现数据交换，同时生成临时会话密钥．由此节省了登录的运算开销，且协议具有前向安全性．研究从形式化论证角度出发，利用通用可组合安全认证理想函数FAUTH模型和密钥交换理想函数 FKE模型，构建πpAKE的通用可组合安全模型，并在此模型下，对πpAKE安全性进行论证，结果表明，该协议具有通用可组合
PAKE: Password-authenticated key agreement
mutourend的博客
07-20 5608
1. 引言 PAKE，即Password-authenticated key agreement，密码认证秘钥协商。 相关代码实现参见： https://github.com/RustCrypto/PAKEs 参考资料 [1] Wikipedia Password-authenticated key agreement
OpenHarmony解读之设备认证：pake协议-客户端发起start请求
weixin_46669761的博客
05-29 1329
一、概述 在设备认证过程中，pake协议用于认证会话密钥协商，基于该会话密钥，双方可以安全地交换各自的身份公钥。从本文开始，将对pake协议的详细过程进行介绍，本博客主要介绍客户端发起start请求的过程，协议状态从PROTOCOL_INIT转换为START_REQUEST。 二、源码分析 这一模块的源码位于：/base/security/deviceauth。 1. start_pake函数，启动pake模块。 /* 函数功能：启动pake模块 函数参数： handle：hichain实例
OpenHarmony解读之设备认证：pake协议-客户端接收end响应
weixin_46669761的博客
05-29 582
一、概述 在上一篇博客中提到，服务端针对客户端发起的end请求，作出了end响应，因此，本文将介绍客户端接收到end响应之后的处理过程。 二、源码分析 这一模块的源码位于：/base/security/deviceauth。 1. 首先执行parse_pake_server_confirm函数解析响应消息。 /* 函数功能：解析服务端confirm消息负载 函数参数： payload：消息负载 data_type：数据类型 函数返回值： 返回pake_end_response_dat
krb5-pake:Kerberos PAKE 预认证机制
06-28
警告：此软件仅用于概念验证，并不安全。 不要用这个软件！... 我不是在开玩笑。 不要使用它。 Kerberos PAKE 什么是派克？ ...为什么 PAKE 对 Kerberos 感兴趣？...Kerberos PAKE 支持哪些 PAKE 算法？ Kerberos PAK
关于S-3PAKE协议的漏洞分析 (2009年)
05-15
通过分析一种基于CCDH假设的简单三方密钥交换协议(S-3PAKE 协议),指出了该协议未对攻击者可能的身份进行全面考虑,缺乏完备认证机制的缺陷,阐明了当攻击者本身就是与服务器共享一对认证口令的合法用户时,该协议不能...
J-PAKE-demo:有限域和椭圆曲线中J-PAKE的Java演示
04-29
J-PAKE演示 有限域和椭圆曲线中J-PAKE的Java演示
cpace:使用 libsodium 的 CPace PAKE 实现
05-31
CPace-Ristretto255，一个平衡的 PAKE libsodium 1.0.17+ 的 CPace 实现 模糊 是一种协议，供共享低熵秘密（密码）的两方派生出强共享密钥，而不会将秘密泄露给离线字典攻击。 CPace 是一个平衡的 PAKE，意味着...
轻松安全地将东西从一台计算机发送到另一台：crocodile：：package：-Golang开发
05-26
AFAIK，croc是唯一可以完成以下所有操作的CLI文件传输工具：允许任何两台计算机传输数据（使用中继）提供端到端加密（使用PAKE），实现轻松的跨平台传输（Windows，Linux） （Mac）允许多个文件传输，允许恢复被中断...
HPACK 协议规范中文版
07-23
HTTP/2 协议的一些关键特性包括：二进制分帧，连接复用，首部压缩等。首部压缩是 HTTP/2 用于减少多请求执行时数据传输量的方法。这份文档是 HTTP/2 首部压缩部分，即 HPACK 的协议规范。
解决OpenSSH J PAKE授权问题漏洞 CVE 2010 4478 Linux上openssh重装方法
07-19
解决OpenSSH J PAKE授权问题漏洞 CVE 2010 4478 需要更新openssh Linux上openssh重装方法
密钥交换协议
11-09
密钥交换协议，国标SM2椭圆曲线公钥密码算法第3部分 密钥交换协议
CCC数字钥匙设计--什么是SPAKE2+?
最新发布
09-10 1160
SPAKE2+是一种增强型的PAKE。英文全称为Simple Password Authenticated Key Exchange。 PAKE，英文全称为 Password Authenticated Key Exchange。
信息摘要算法之六：HKDF算法分析与实现
weixin_30861459的博客
03-25 1531
HKDF是一种特定的键衍生函数(KDF)，即初始键控材料的功能，KDF从其中派生出一个或多个密码强大的密钥。在此我们想要描述的是基于HMAC的HKDF。 1、HKDF概述 密钥派生函数(KDF)是密码系统的基本组成部分。它的目标是获取一些初始的密钥材料，并从中派生出一个或多个安全强度很大的密钥。 我们将要介绍的是基于HMAC的KDF，称之为HKDF，它可以应用于各种协议和应用程序的构建。HK...
OpenHarmony轻量级设备xts认证大致流程
疯狂飙车的蜗牛的博客
01-13 2088
OpenHarmony轻量级设备xts认证大致流程
网络组件axios可以在OpenHarmony上使用了
OpenHarmony_dev的博客
08-29 1496
简单来说，ohos/axios依赖开源社区axios三方组件，并根据axios现有的框架实现了ohadapter，即在OpenHarmony中适配网络调用，对外暴露axios的原有对象，因此可以保障axios的api及特性都完全继承。我们可以看到axios既可以在浏览器中使用，又可以在Nodejs中使用，而如今随着OpenHarmony ArkUI的发展，axios又有了新的用武之地，即在OpenHarmony标准系统的应用中使用：可用于网络请求和上传下载文件，并完全继承axios原生的用法和所有特性。..
OpenSSH J-PAKE授权问题漏洞
weixin_34292287的博客
09-30 1192
漏洞名称：OpenSSHJ-PAKE授权问题漏洞(CVE-2010-4478)漏洞说明：OpenSSH是SSH协议组的实现，可为各种服务提供加密的认证传输，包括远程shell访问。当J-PAKE启用时，OpenSSH5.6及之前版本不能正确验证J-PAKE协议中的公共参数。远程***者可以通过发送每一轮协议中的特制值绕过共享秘密信息的需求，并成功获得认证。解决方法：卸载系...
OpenHarmony解读之设备认证：pake协议-服务端响应pake start请求(2)
weixin_46669761的博客
05-29 478
一、概述 本文将继续介绍服务端响应pake协议的start请求的过程，承接上文：OpenHarmony解读之设备认证：pake协议-服务端响应pake start请求(1)。 二、源码分析 这一模块的源码位于：/base/security/deviceauth。 1. 在上文中创建完pake服务端对象之后，开始进入消息处理阶段，根据协议模块字段在全局分布式消息表中查询对应的消息处理函数，此处应该是proc_pake_request_message函数。 /* 函数功能：处理pake请求消息 函数参数：
python thinker label pake
05-09
Python Tkinter Label Widget (Python Tkinter 标签小部件) 是 Tkinter GUI 工具包中的一个小部件，用于在应用程序中显示文本或图像标签。它可以用来创建静态文本或图像，并在图形用户界面中展示。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值