security_huks模块下hks_rkc.c代码评注第五部分

最新推荐文章于 2024-11-08 21:24:28 发布
最新推荐文章于 2024-11-08 21:24:28 发布
阅读量183 收藏
点赞数 1
分类专栏： security_huks OpenHarmony 文章标签： c语言 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HORHEART/article/details/120001471
版权

security_huks模块下hks_rkc.c代码评注第五部分

本篇概述

本篇是接着：

在讲解完关密钥获取以及写所有密钥库文件的相关函数后，本篇将继续讲述hks_rkc.c代码中有关密钥的生成、为密钥加掩码、密钥内存的恢复相关操作。

代码框架

hks_rkc.c
├── 密钥加密、生成与掩码
│ └── hks_rkc_mk_crypt
│ └── hks_rkc_mask_mk
│ └── hks_rkc_make_mk
│ └── hks_rkc_create_ksf
├── 密钥内存恢复
│ └── hks_rkc_recover_mk_mem
│ └── hks_rkc_recover_rk_mem
│ └── hks_rkc_load_ksf

密钥加密、生成与掩码

1. hks_rkc_mk_crypt

  • 函数功能：为主密钥做加密操作
    root key component - do crypt operation for master key

  • 参数说明：为密钥库文件载入的数据、主密钥对应明文（输入输出）、主密钥对应密文（输入输出）、操作（包含根密钥组件的加密与解密）
    parameter:
    ksf_data - [in] - the data which loaded from keystore file.
    plaintext - [in,out] - the plaintext of master key
    ciphertext - [in,out] - the ciphertext of master key
    operation - [in] - operation, HKS_RKC_ENCRYPT or HKS_RKC_DECRYPT.

  • 返回值：成功或错误代码
    return value:
    success or error code

详细代码及评注如下：

static int32_t hks_rkc_mk_crypt(struct hks_rkc_ksf_data *ksf_data,
    struct hks_blob *plaintext, struct hks_blob *ciphertext,
    uint8_t operation)
{
    //为根主密钥开辟存储空间
    uint8_t *rmk = (uint8_t *)HKS_MALLOC(HKS_RKC_RMK_LEN);

    //检查是否成功开辟空间
    if (rmk == NULL) {
        log_error("malloc rmk fail");
        return HKS_ERROR_MALLOC_FAIL;
    }

    int32_t rc;

    do {
        //获取派生根主密钥，将根主密钥存放在rmk中
        rc = hks_rkc_derive_rmk(ksf_data, rmk, HKS_RKC_RMK_LEN);
        if (rc != HKS_STATUS_OK)
            break;

        //创建变量key，内部存放根主密钥数据
        struct hks_blob key = { HKS_BLOB_TYPE_KEY, rmk, HKS_RKC_RMK_EK_LEN };

        //创建密钥参数、aead数据等变量
        size_t output_len = 0;
        struct hks_key_param key_param;
        struct hks_aead_data aead_data;

        //将key_param、aead_data的内存数据初始化为0
        (void)memset_s(&key_param, sizeof(key_param), 0, sizeof(key_param));
        (void)memset_s(&aead_data, sizeof(aead_data), 0, sizeof(aead_data));
        //将一系列默认参数，与明文密文信息写入
        key_param.key_len = HKS_MAX_KEY_LEN_256;
        key_param.key_type = HKS_KEY_TYPE_AES;
        key_param.key_mode = HKS_ALG_GCM;
        aead_data.nonce = ksf_data->mk_iv;
        aead_data.nonce_length = HKS_RKC_MK_IV_LEN;
        aead_data.additional_data = g_hks_rkc_mk_add_data;
        aead_data.additional_data_length = HKS_RKC_MK_ADD_DATA_LEN;
        aead_data.ciphertext = ciphertext->data;
        aead_data.ciphertext_length = ciphertext->size;
        aead_data.plaintext = plaintext->data;
        aead_data.plaintext_length = plaintext->size;
        //依据传入参数operation来决定是进行主密钥对应密文的加密还是解密
        if (operation == HKS_RKC_ENCRYPT) {
            //调用aead算法加密
            rc = hks_mbedtls_aead_encrypt(&key, &key_param,
                &aead_data, &output_len);
        } else if (operation == HKS_RKC_DECRYPT) {
            //调用aead算法解密
            rc = hks_mbedtls_aead_decrypt(&key, &key_param,
                &aead_data, &output_len);
        } else {
            //错误操作判定
            log_error("invalid operation=%u", operation);
            rc = HKS_ERROR_INVALID_ARGUMENT;
            break;
        }
        if (rc != HKS_STATUS_OK) {
            log_error("mbedtls aead encrypt fail, rc=%d", rc);
            break;
        }
    } while (0);

    //根密钥的数据在使用后应清除
    /* the data of root key should be cleared after use */
    (void)memset_s(rmk, HKS_RKC_RMK_LEN, 0, HKS_RKC_RMK_LEN);
    hks_free_ptr(rmk);

    return rc;
}

2. hks_rkc_mask_mk

  • 函数功能：对主密钥进行掩码
    root key component - mask master key
  • 参数说明：输入掩码参数
    parameter:
    mk - [in] - mask.
  • 返回值：无
    return value: none

详细代码及评注如下：

static void hks_rkc_mask_mk(const struct hks_blob *mk)
{
    //定义有关主密钥掩码的结构体变量
    //g_hks_rkc_cfg.mk_mask为根密钥组件的配置中的主密钥掩码
    //g_hks_rkc_mk.mk_with_mask为主密钥的数据中的主密钥掩码
    struct hks_blob mk_mask = { HKS_BLOB_TYPE_KEY, g_hks_rkc_cfg.mk_mask, HKS_RKC_MK_LEN };
    struct hks_blob mk_with_mask = { HKS_BLOB_TYPE_KEY, g_hks_rkc_mk.mk_with_mask, HKS_RKC_MK_LEN };

    hks_xor(mk, &mk_mask, &mk_with_mask);
    //将主密钥设置为合法
    g_hks_rkc_mk.is_valid = HKS_BOOL_TRUE;
}

该部分中的掩码操作实质上就是异或操作，主要代码调用了hks_common.c中的函数hks_xor，下面给出函数hks_xor的详细解释：

  • 函数功能：异或操作
    XOR operation
  • 参数说明：1号和2号数据源、结果
    parameter:
    src1 - [in] - source data #1.
    src2 - [in] - source data #2.
    result - [out] - result.
  • 返回值：无
    return value: none

详细代码如下：

 void hks_xor(const struct hks_blob* src1, const struct hks_blob* src2,
        struct hks_blob* result)
    {
        //判空操作
        if ((src1 == NULL) || (src2 == NULL) || (result == NULL))
            return;

        //确定异或操作的位数，取更小的为xor_len
        uint32_t xor_len = (src1->size < src2->size) ? src1->size : src2->size;

        if (xor_len > result->size)
            xor_len = result->size;

        uint32_t i;

        //执行异或操作
        for (i = 0; i < xor_len; ++i)
            result->data[i] = src1->data[i] ^ src2->data[i];
    }

3. hks_rkc_make_mk

  • 函数功能：生成主密钥
    root key component - make master key

  • 参数说明：为密钥库文件载入的数据
    parameter:
    ksf_data - [in,out] - the data which loaded from keystore file.

  • 返回值：成功或错误代码
    return value:
    success or error code

生成主密钥的主要思路是利用生成随机数函数hks_gen_random生成主密钥的掩码、IV以及主密钥本身，然后对定义好的密文数据调用为主密钥加密函数hks_rkc_mk_crypt，使用aead算法对其进行解密，得到最终的数据即为我们想要的主密钥。详细代码及评注如下：

static int32_t hks_rkc_make_mk(struct hks_rkc_ksf_data *ksf_data)
{
    //定义并初始化主密钥mk
    struct hks_blob mk;
    int32_t rc = hks_blob_init(&mk, sizeof(uint8_t), HKS_RKC_MK_LEN,
        HKS_BLOB_TYPE_KEY);

    //检查初始化状态
    if (rc != HKS_STATUS_OK) {
        log_error("init mk fail");
        return HKS_ERROR_MALLOC_FAIL;
    }

    do {
        //将主密钥的加密算法写入ksf_data中
        ksf_data->mk_encrypt_alg = g_hks_rkc_cfg.mk_encrypt_alg;

        //生成主密钥掩码（利用生成随机数函数hks_gen_random）
        /* generate the mask of master key */
        rc = hks_gen_random(g_hks_rkc_cfg.mk_mask, HKS_RKC_MK_LEN);
        if (rc != HKS_STATUS_OK)
            break;

        //生成主密钥
        /* generate master key */
        rc = hks_gen_random(mk.data, mk.size);
        if (rc != HKS_STATUS_OK)
            break;

        //生成主密钥IV
        /* generate the IV of master key */
        rc = hks_gen_random(ksf_data->mk_iv, HKS_RKC_MK_IV_LEN);
        if (rc != HKS_STATUS_OK)
            break;

        //定义并初始化主密钥密文
        struct hks_blob ciphertext = { HKS_BLOB_TYPE_KEY, ksf_data->mk_ciphertext, HKS_RKC_MK_CIPHERTEXT_LEN };
        //调用为主密钥加密函数hks_rkc_mk_crypt，使用aead算法对其进行解密
        rc = hks_rkc_mk_crypt(ksf_data, &mk, &ciphertext,
            HKS_RKC_ENCRYPT);
        if (rc != HKS_STATUS_OK)
            break;

        //在内存中的主密钥需要做掩码操作
        /* the master key in memory should be masked */
        hks_rkc_mask_mk(&mk);
    } while (0);

    //释放主密钥内存空间
    hks_blob_destroy(&mk);

    return rc;
}

4. hks_rkc_create_ksf

  • 函数功能：创建密钥库文件
    root key component - creat keystore file

  • 无参数
    parameter: none

  • 返回值：成功或错误代码
    return value:
    success or error code

创建密钥库文件的思路是生成一个新的密钥库文件数据（包括：版本号、根主密钥迭代次数、根主密钥使用的hash算法、两个材料、盐化值、主密钥），接着调用函数hks_rkc_write_all_ksf将根密钥组件数据写入所有的密钥库文件中。详细代码及评注如下：

static int32_t hks_rkc_create_ksf(void)
{
    //定义根密钥组件的密钥库文件数据结构体变量new_ksf_data并做内存空间分配
    struct hks_rkc_ksf_data *new_ksf_data =
        (struct hks_rkc_ksf_data *)HKS_MALLOC(HKS_RKC_KSF_DATA_SIZE);

    if (new_ksf_data == NULL) {
        log_error("malloc ksf data fail");
        return HKS_ERROR_MALLOC_FAIL;
    }

    //根密钥组件数据在一开始必须被清除（置零）
    /* The root key component data must be clear firstly. */
    (void)memset_s(new_ksf_data, HKS_RKC_KSF_DATA_SIZE, 0,
        HKS_RKC_KSF_DATA_SIZE);

    int32_t rc;

    do {
        //填写一些固定的数据，包括版本号、根主密钥迭代次数、根主密钥使用的hash算法
        /* Fill some fixed field. */
        new_ksf_data->version = g_hks_rkc_cfg.version;
        new_ksf_data->rmk_iter = g_hks_rkc_cfg.rmk_iter;
        new_ksf_data->rmk_hash_alg = g_hks_rkc_cfg.rmk_hash_alg;

        //两个材料都是由随机数生成
        /* Two material are generated by random number. */
        rc = hks_rkc_make_random_material(new_ksf_data);
        if (rc != HKS_STATUS_OK) {
            log_error("generate material fail,rc=%d", rc);
            break;
        }

        //盐化值也是由随机数生成
        /* The salt value is generated by random number. */
        rc = hks_gen_random(new_ksf_data->rmk_salt, HKS_RKC_SALT_LEN);
        if (rc != HKS_STATUS_OK) {
            log_error("generate rmk_salt fail,rc=%d", rc);
            break;
        }

        //创建主密钥
        /* make master key. */
        rc = hks_rkc_make_mk(new_ksf_data);
        if (rc != HKS_STATUS_OK) {
            log_error("make mk fail,rc=%d", rc);
            break;
        }

        //将根密钥组件数据写入所有的密钥库文件中
        /* Write the root key component data into all keystore files */
        rc = hks_rkc_write_all_ksf(new_ksf_data);
        if (rc != HKS_STATUS_OK)
            break;

        //更新日志信息
        log_info("create root key component success");
    } while (0);

    //根密钥数据需要在使用完后被清理
    /* the data of root key should be cleared after use */
    (void)memset_s(new_ksf_data, HKS_RKC_KSF_DATA_SIZE, 0,
        HKS_RKC_KSF_DATA_SIZE);
    hks_free_ptr(new_ksf_data);//释放内存空间

    return rc;
}

密钥内存恢复

1. hks_rkc_recover_mk_mem

  • 函数功能：恢复主密钥内存
    root key component - recover master key memory

  • 参数说明：为密钥库文件载入的数据
    parameter:
    ksf_data - [in] - the data which loaded from keystore file.

  • 返回值：成功或错误代码
    return value:
    success or error code

详细代码及评注如下：

static int32_t hks_rkc_recover_mk_mem(struct hks_rkc_ksf_data *ksf_data)
{
    //将ksf_data中的主密钥创建时间复制到事先定义好的主密钥数据g_hks_rkc_mk中
    int32_t rc = memcpy_s(&(g_hks_rkc_mk.mk_created_time),
        sizeof(g_hks_rkc_mk.mk_created_time),
        &(ksf_data->mk_created_time),
        sizeof(ksf_data->mk_created_time));

    if (rc != HKS_STATUS_OK)
        return HKS_ERROR_INTERNAL_UNKOWN;

    将ksf_data中的主密钥过期时间复制到事先定义好的主密钥数据g_hks_rkc_mk中
    rc = memcpy_s(&(g_hks_rkc_mk.mk_expired_time),
        sizeof(g_hks_rkc_mk.mk_expired_time),
        &(ksf_data->mk_expired_time),
        sizeof(ksf_data->mk_expired_time));
    if (rc != HKS_STATUS_OK)
        return HKS_ERROR_INTERNAL_UNKOWN;

    struct hks_blob mk;

    //主密钥的初始化
    rc = hks_blob_init(&mk, sizeof(uint8_t), HKS_RKC_MK_LEN,
        HKS_BLOB_TYPE_KEY);
    if (rc != HKS_STATUS_OK) {
        log_error("init mk fail");
        return HKS_ERROR_MALLOC_FAIL;
    }

    do {
        //调用生成随机数函数生成主密钥的掩码
        /* generate the mask of master key */
        rc = hks_gen_random(g_hks_rkc_cfg.mk_mask, HKS_RKC_MK_LEN);
        if (rc != HKS_STATUS_OK)
            break;

        struct hks_blob ciphertext = { HKS_BLOB_TYPE_KEY, ksf_data->mk_ciphertext, HKS_RKC_MK_CIPHERTEXT_LEN };

        //为主密钥做解密操作HKS_RKC_DECRYPT
        rc = hks_rkc_mk_crypt(ksf_data, &mk, &ciphertext,
            HKS_RKC_DECRYPT);
        if (rc != HKS_STATUS_OK) {
            rc = HKS_ERROR_INVALID_KEY_FILE;
            break;
        }

        //在内存中的主密钥需要做掩码操作
        /* the master key in memory should be masked */
        hks_rkc_mask_mk(&mk);
    } while (0);

    //释放主密钥空间
    hks_blob_destroy(&mk);

    return rc;
}

2. hks_rkc_recover_rk_mem

  • 函数功能：恢复根密钥内存
    root key component - recover root key memory

  • 参数说明：为密钥库文件载入的数据
    parameter:
    ksf_data - [in] - the data which loaded from keystore file.

  • 返回值：成功或错误代码
    return value:
    success or error code

详细代码及评注如下：

static int32_t hks_rkc_recover_rk_mem(const struct hks_rkc_ksf_data *ksf_data)
{
    //将ksf_data中的根密钥创建时间复制到事先定义好的根密钥组件配置g_hks_rkc_cfg中
    int32_t rc = memcpy_s(&(g_hks_rkc_cfg.rk_created_time),
        sizeof(g_hks_rkc_cfg.rk_created_time),
        &(ksf_data->rk_created_time),
        sizeof(ksf_data->rk_created_time));

    if (rc != HKS_STATUS_OK)
        return HKS_ERROR_INTERNAL_UNKOWN;

    将ksf_data中的根密钥过期时间复制到事先定义好的根密钥组件配置g_hks_rkc_cfg中
    rc = memcpy_s(&(g_hks_rkc_cfg.rk_expired_time),
        sizeof(g_hks_rkc_cfg.rk_expired_time),
        &(ksf_data->rk_expired_time),
        sizeof(ksf_data->rk_expired_time));
    if (rc != HKS_STATUS_OK)
        return HKS_ERROR_INTERNAL_UNKOWN;

    return HKS_STATUS_OK;
}

3. hks_rkc_load_ksf

  • 函数功能：载入密钥库文件
    root key component - load keystore file

  • 参数说明：密钥库文件数据
    parameter:
    ksf_data - [out] - the data of keystore file.

  • 返回值：成功或错误代码
    return value:
    success or error code

该部分是对上面定义函数的一个封装，包括读取所有密钥库文件、恢复根密钥内存、恢复主密钥内存、检查所有密钥库文件等。详细代码及评注如下：

static int32_t hks_rkc_load_ksf(struct hks_rkc_ksf_data *ksf_data)
{
    int32_t all_ksf_rc[HKS_RKC_KSF_NUM] = {0};
    uint32_t data_size = HKS_RKC_KSF_DATA_SIZE * HKS_RKC_KSF_NUM;

    //定义hks_rkc_ksf_data结构体变量all_ksf_data以放所有密钥库文件数据，并做内存空间的分配
    struct hks_rkc_ksf_data *all_ksf_data =
        (struct hks_rkc_ksf_data *)HKS_MALLOC(data_size);

    if (all_ksf_data == NULL) {
        log_error("malloc all ksf data fail");
        return HKS_ERROR_MALLOC_FAIL;
    }

    //将all_ksf_data中的数据置零
    (void)memset_s(all_ksf_data, data_size, 0, data_size);

    int32_t rc;

    do {
        uint32_t valid_ksf_index = 0;
        //定义根密钥组件密钥库文件数据结构体变量valid_ksf_data并制空
        struct hks_rkc_ksf_data *valid_ksf_data = NULL;

        //读取所有密钥库文件到all_ksf_data中
        rc = hks_rkc_read_all_ksf(all_ksf_rc, all_ksf_data,
            &valid_ksf_data,
            &valid_ksf_index);
        if (rc != HKS_STATUS_OK)
            break;

        //检查有效密钥库文件数据
        if (valid_ksf_data == NULL) {
            log_error("all ksf file are invalid");
            rc = HKS_ERROR_INVALID_KEY_FILE;
            break;
        }

        //恢复根密钥内存
        rc = hks_rkc_recover_rk_mem(valid_ksf_data);
        if (rc != HKS_STATUS_OK)
            break;

        //恢复主密钥内存
        rc = hks_rkc_recover_mk_mem(valid_ksf_data);
        if (rc != HKS_STATUS_OK)
            break;

        //检查所有密钥库文件
        rc = hks_rkc_chk_all_ksf(all_ksf_rc, all_ksf_data,
            valid_ksf_data,
            valid_ksf_index);
        if (rc != HKS_STATUS_OK)
            break;

        //将有效密钥库文件数据valid_ksf_data复制到ksf_data中
        if (ksf_data != NULL) {
            rc = memcpy_s(ksf_data, HKS_RKC_KSF_DATA_SIZE,
                valid_ksf_data,
                HKS_RKC_KSF_DATA_SIZE);
            if (rc != HKS_STATUS_OK)
                break;
        }

        //更新日志：成功载入密钥库文件
        log_info("load ksf success");
    } while (0);

    //内存数据置零接着释放
    (void)memset_s(all_ksf_data, data_size, 0, data_size);
    hks_free_ptr(all_ksf_data);

    return rc;
}

本章小结

本篇继续讲述了hks_rkc.c代码中有关密钥的生成、为密钥加掩码、密钥内存的恢复相关操作，下一篇将继续更新hks_rkc.c代码中有关密钥初始化、销毁以及检查的部分功能。

鸿蒙security-huks的层次分析-国家一级假勤奋大学生制作
11-20
鸿蒙操作系统中的security_huks是其安全框架的重要组成部分，主要用于处理加密、解密、签名等安全相关的任务。本文将深入解析security_huks的各层次结构，帮助开发者理解和掌握其核心功能。 1. **frameworks层** -...
Hi3861_海思官方_安全模块使用指南1
08-04
【Hi3861安全模块使用指南】 本文档是针对Hi3861V100和Hi3861LV100芯片的安全模块使用的详细介绍，由上海海思技术有限公司编写并拥有版权。该指南旨在帮助技术支持工程师和软件开发工程师理解并有效利用安全模块的...
鸿蒙高级开发者认证题库
05-21
**5. HarmonyOS与OpenHarmony兼容性** - **正确判断：** HarmonyOS应用可以兼容OpenHarmony生态。 - HarmonyOS与OpenHarmony之间存在一定的兼容性，开发者可以根据需求选择开发平台。 **6. 页面栈管理** - **正确...
HarmonyOS应用开发者高级认证 word试题及答案
12-21
5. **发布流程**：发布应用时需创建发布Profile，选择发布类型，发布后应用可在华为应用市场获取。 **四、测试与发布** 1. **开放式测试**：发布后，测试用户可通过服务中心的“开发者测试”体验，测试用户添加需...
[练习题+答案]Harmony OS应用开发者高级认证
06-01
- **知识点21**：HUKS(通用密钥库系统)为HarmonyOS提供了一整套密钥管理和加密解密的功能，是确保应用数据安全的重要组成部分。 - **知识点22**：关于容器组件`Row`和`Column`的描述，二者确实存在主轴和交叉轴的...
打印九九乘法表（全部，左上，左下，右上，右下）（C语言）
xinghuitunan的博客
11-07 920
愿我们都能成为我们想要去成为的人！但行前路，不负韶华！余生很长，不必慌张！
ICT网络赛道安全考点知识总结4
m0_72765822的博客
11-04 748
RADIUS和HWTACACS协议通常都使用共享密钥对传输的用户信息进行加密，以确保安全传输。 用来封装EAP报文的RADIUS属性通常是"EAP-Message"，它用于传输EAP认证过程中的消息。 LDAP的域名属性通常是"DC"（Domain Component），用于表示域名的组成部分。 BFD（Bidirectional Forwarding Detection）可以用于检测网络设备之间直连物理链路的双向转发路径的故障，但也可以用于检测其他类型的链路故障。 管理员为虚拟系统手工分配资源时，
Neo4j数据库清理指南：如何安全地删除所有节点和索引
engchina的专栏
11-05 522
Neo4j数据库清理指南：如何安全地删除所有节点和索引
微软日志丢失事件敲响安全警钟
juminfo的博客
11-08 274
据报告，从9月2日至9月19日，持续长达两周的时间里，微软的多项核心云服务，包括身份验证平台Microsoft Entra、安全信息与事件管理（SIEM）平台Sentinel、云安全解决方案Defender for Cloud以及数据目录服务Purview，都经历了安全日志记录的空白期。系统可以实时、不间断地收集并整合各类设备的日志信息，通过先进的关联分析技术和机器学习手段，助力用户从庞杂的日志数据中快速识别异常安全事件，全面满足合规审计、分析调查及数据留存等多日志场景使用需求。
信息安全工程师（82）操作系统安全概述
m0_73399576的博客
11-08 815
信息安全工程师——操作系统安全概述篇
shodan 【2】（泷羽sec）
m0_68984471的博客
11-08 633
shodan的使用方法
【AI写作宝-注册安全分析报告-无验证方式导致安全隐患】
11-08 445
AI写作宝是一款基于人工智能技术的在线写作辅助工具，由合肥风平网络信息科技有限公司开发。它旨在帮助用户提升写作效率，通过AI技术自动生成文章、文案、作文等，适用于多种写作场景。该网站好像属于灰色地带的业务， 网站介绍什么的都没有，更容易被黑客攻击， 好像对短信被盗刷的安全方面不够重视 ，测试结果就是随便你怎么攻击都可以，这也有点太开放了， 短信验证码难道不要钱吗？这对黑客来说肯定是好消息， 弄个简单的脚本就可以搞定很多人在短信服务刚开始建设的阶段，可能不会在安全方面考虑太多，理由有很多。比如：“
【基于LSM的ELF文件安全模块设计】参考
weixin_50947533的博客
11-04 706
本设计致力于通过 Linux 安全模块（LSM）构建一个强大而严密的安全防护体系，以实现对 ELF 文件（涵盖可执行文件和动态链接库）的绝对严格的合法性和完整性检查。其核心目标在于确保系统在加载和运行各类 ELF 文件时，能够有效抵御来自未知来源或被恶意篡改的文件所可能带来的严重安全威胁，如数据泄漏、系统崩溃等，进而全力维护系统的高度稳定性和数据的绝对安全性。
【 AI写作鹅-注册安全分析报告-无验证方式导致安全隐患】
最新发布
11-08 688
合肥名阳信息技术有限公司成立于2016年，是一家专门从事移动互联网应用研发和运营的国家高新技术企业。公司坚持以用户为中心，打造富有吸引力的产品，满足移动互联网用户各项需求。公司产品涵盖：AI配音、AI写作、AiPPT、同声传译、文生视频，AI绘画、各种工具类应用，为消费者提供完善的办公、多媒体等领域的解决方案，秉承着专业、服务、高效、客户至上的原则，多年来致力于为用户提供服务新体验。
国标GB28181网页直播平台EasyGBS国标GB28181软件的应急管理与安全生产解决方案
EasyGBS的博客
11-04 833
EasyGBS作为国标GB28181协议的视频融合管理平台，能够实现全天候、稳定的安防监控，加强事件预防、应急处理和事后追责，缩短信息传递时间，构建覆盖市、县的纵向网络，并与相关单位联通。
案例精选 | 河北省某检察院安全运营中异构日志数据融合的实践探索
juminfo的博客
11-08 554
河北省某检察院是当地重要的法律监督机构，肩负着维护法律尊严和社会公平正义的重要职责。该机构依法独立行使检察权，负责对犯罪行为提起公诉，并监督整个诉讼过程，同时积极参与社会治理，保护公民权益，推动法治社会的建设与发展。近年来，随着信息化技术的快速发展，河北省某检察院积极响应国家号召，倡导并实践“智慧检察”的先进理念，致力于推进检察工作的现代化转型。特别是在数字化检委会会议系统的建设上取得了显著成效，成功实现了会议的“无纸化”操作。
OWASP TOP10 OSS 风险：开源软件安全指南
分享web安全、AI安全、云安全、业务安全、渗透测试、安全开发、安全工具、行业动态等优质内容……
11-05 514
另一个导致开源码软件未维护的关键因素是，近25%的开源软件项目只有一个开发人员贡献代码，94%的项目由10个或更少的开发人员维护，正如研究员Chinmayi Sharma在她的出版物 “A Tragedy of the Digital Commons” 中引用的那样，对于那些想要全面了解开源挑战的人来说，这是一本推荐的读物。软件组件可能不会被积极开发或维护，缺陷的修复可能不会发生，或者即使有，也可能不在使用组件的软件消费者所期望的时间表上，也不符合专有供应商关于与下游客户的漏洞修复的 SLA。
数字身份发展趋势前瞻：身份韧性与安全
trusfort的博客
11-05 461
面对日益复杂的网络威胁和不断增长的身份盗窃风险，身份韧性与安全不仅仅涉及产品的防御能力，还包括应对突发事件、快速恢复的弹性和灵活性。
用户登录密码存储加密策略（附Python 和 bcrypt 库进行安全密码验证）
2301_80892630的博客
11-08 245
为确保用户密码的安全存储，我们需要遵循最佳实践，确保密码被安全地加密和存储。以下是实现安全密码存储的步骤和示例代码。
信息安全工程师（77）常见网络安全应急事件场景与处理流程
m0_73399576的博客
11-05 943
信息安全工程师——常见网络安全应急事件场景与处理流程篇
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值