From: luozheng <1732036298@qq.com> Date: Sat, 19 Jul 2025 06:37:59 +0000 (+0800) Subject: open_source文件夹下的openharmony下的base文件夹合并提交 X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~238 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=430eecfc54006396046aa991f07b0960d16ad732;p=mirrors%2FFD230.git open_source文件夹下的openharmony下的base文件夹合并提交 --- diff --git a/code/sdk/open_source/openharmony/base/security/appverify/app_mbedtls_pkcs7.c b/code/sdk/open_source/openharmony/base/security/appverify/app_mbedtls_pkcs7.c index fc206634a..f966b0ba5 100644 --- a/code/sdk/open_source/openharmony/base/security/appverify/app_mbedtls_pkcs7.c +++ b/code/sdk/open_source/openharmony/base/security/appverify/app_mbedtls_pkcs7.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * Copyright (c) 2020-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -14,20 +14,27 @@ */ #include "mbedtls_pkcs7.h" - -#include -#include +#include #include -#include - -#include "mbedtls/platform.h" // for mbedtls_calloc +#include +#include +#include +#include +#include +#include "app_common.h" #include "securec.h" - -#include "verify_util_log.h" - -#define VERIFY_BUF_LEN 512 -#define MAX_SIG_SIZE 1024 -#define MAX_HASH_SIZE 64 +#include "mbedtls/platform.h" +#include +#include +#include +#include +#include "mbedtls/entropy.h" +#include "mbedtls/ctr_drbg.h" +#include +#include +#include +#include "log.h" +#include "nv.h" /* * below pkcs-7 and pkcs-9 oid definition is not defined in mbedtls now @@ -54,35 +61,30 @@ #define DER_FORMAT_SINGED_DATA 2 #define PKCS7_ERR_GOTO_OUT(rc) \ - do { \ - if ((rc) != PKCS7_SUCC) \ - { \ - goto OUT; \ - } \ + do { \ + if ((rc) != PKCS7_SUCC) \ + { \ + HILOG_ERROR(HILOG_MODULE_AAFWK, "%s:%u, error occurred, ret:%d", __FUNCTION__, __LINE__, (rc)); \ + return rc; \ + } \ } while (0) -/* - * for now, there's only one root ca - * so we do not duplicate load root ca for every signer - * but just let the signer's rootca point to this. - */ static mbedtls_x509_crt g_rootCaG2Cert; static bool g_rootCertLoaded; static const unsigned char g_rootCaG2CertInPem[] = "-----BEGIN CERTIFICATE-----\r\n" - "MIICRDCCAcmgAwIBAgIED+E4izAMBggqhkjOPQQDAwUAMGgxCzAJBgNVBAYTAkNO\r\n" - "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\r\n" - "bTEoMCYGA1UEAxMfT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gUm9vdCBDQTAeFw0y\r\n" - "MTAyMDIxMjE0MThaFw00OTEyMzExMjE0MThaMGgxCzAJBgNVBAYTAkNOMRQwEgYD\r\n" - "VQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVhbTEoMCYG\r\n" - "A1UEAxMfT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gUm9vdCBDQTB2MBAGByqGSM49\r\n" - "AgEGBSuBBAAiA2IABE023XmRaw2DnO8NSsb+KG/uY0FtS3u5LQucdr3qWVnRW5ui\r\n" - "QIL6ttNZBEeLTUeYcJZCpayg9Llf+1SmDA7dY4iP2EcRo4UN3rilovtfFfsmH4ty\r\n" - "3SApHVFzWUl+NwdH8KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC\r\n" - "AQYwHQYDVR0OBBYEFBc6EKGrGXzlAE+s0Zgnsphadw7NMAwGCCqGSM49BAMDBQAD\r\n" - "ZwAwZAIwd1p3JzHN93eoPped1li0j64npgqNzwy4OrkehYAqNXpcpaEcLZ7UxW8E\r\n" - "I2lZJ3SbAjAkqySHb12sIwdSFKSN9KCMMEo/eUT5dUXlcKR2nZz0MJdxT5F51qcX\r\n" - "1CumzkcYhgU=\r\n" + "MIICGjCCAaGgAwIBAgIIShhpn519jNAwCgYIKoZIzj0EAwMwUzELMAkGA1UEBhMC\r\n" + "Q04xDzANBgNVBAoMBkh1YXdlaTETMBEGA1UECwwKSHVhd2VpIENCRzEeMBwGA1UE\r\n" + "AwwVSHVhd2VpIENCRyBSb290IENBIEcyMB4XDTIwMDMxNjAzMDQzOVoXDTQ5MDMx\r\n" + "NjAzMDQzOVowUzELMAkGA1UEBhMCQ04xDzANBgNVBAoMBkh1YXdlaTETMBEGA1UE\r\n" + "CwwKSHVhd2VpIENCRzEeMBwGA1UEAwwVSHVhd2VpIENCRyBSb290IENBIEcyMHYw\r\n" + "EAYHKoZIzj0CAQYFK4EEACIDYgAEWidkGnDSOw3/HE2y2GHl+fpWBIa5S+IlnNrs\r\n" + "GUvwC1I2QWvtqCHWmwFlFK95zKXiM8s9yV3VVXh7ivN8ZJO3SC5N1TCrvB2lpHMB\r\n" + "wcz4DA0kgHCMm/wDec6kOHx1xvCRo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T\r\n" + "AQH/BAUwAwEB/zAdBgNVHQ4EFgQUo45a9Vq8cYwqaiVyfkiS4pLcIAAwCgYIKoZI\r\n" + "zj0EAwMDZwAwZAIwMypeB7P0IbY7c6gpWcClhRznOJFj8uavrNu2PIoz9KIqr3jn\r\n" + "BlBHJs0myI7ntYpEAjBbm8eDMZY5zq5iMZUC6H7UzYSix4Uy1YlsLVV738PtKP9h\r\n" + "FTjgDHctXJlC5L7+ZDY=\r\n" "-----END CERTIFICATE-----\r\n"; static mbedtls_x509_crt g_debugModeRootCert; @@ -102,6 +104,905 @@ static const unsigned char g_debugModeRootCertInPem[] = "7XL/vJcp3HeHjiXu7XZmYQ+QAvHPhU0CMCiwWFbDl8ETw4VK25QbwhL/QiUfiRfC\r\n" "J6LzteOvjLTEV5iebQMz/nS1j7/oj3Rsqg==\r\n" "-----END CERTIFICATE-----\r\n"; +static mbedtls_x509_crt g_ohosRootCert; +static const unsigned char OHOS_ROOT_CERT_IN_PEM[] = + "-----BEGIN CERTIFICATE-----\r\n" + "MIICRDCCAcmgAwIBAgIED+E4izAMBggqhkjOPQQDAwUAMGgxCzAJBgNVBAYTAkNO\r\n" + "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\r\n" + "bTEoMCYGA1UEAxMfT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gUm9vdCBDQTAeFw0y\r\n" + "MTAyMDIxMjE0MThaFw00OTEyMzExMjE0MThaMGgxCzAJBgNVBAYTAkNOMRQwEgYD\r\n" + "VQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVhbTEoMCYG\r\n" + "A1UEAxMfT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gUm9vdCBDQTB2MBAGByqGSM49\r\n" + "AgEGBSuBBAAiA2IABE023XmRaw2DnO8NSsb+KG/uY0FtS3u5LQucdr3qWVnRW5ui\r\n" + "QIL6ttNZBEeLTUeYcJZCpayg9Llf+1SmDA7dY4iP2EcRo4UN3rilovtfFfsmH4ty\r\n" + "3SApHVFzWUl+NwdH8KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC\r\n" + "AQYwHQYDVR0OBBYEFBc6EKGrGXzlAE+s0Zgnsphadw7NMAwGCCqGSM49BAMDBQAD\r\n" + "ZwAwZAIwd1p3JzHN93eoPped1li0j64npgqNzwy4OrkehYAqNXpcpaEcLZ7UxW8E\r\n" + "I2lZJ3SbAjAkqySHb12sIwdSFKSN9KCMMEo/eUT5dUXlcKR2nZz0MJdxT5F51qcX\r\n" + "1CumzkcYhgU=\r\n" + "-----END CERTIFICATE-----\r\n"; + +#define VERIFY_BUF_LEN 512 +#define MAX_CERTPATH_LEN 256 +#define OEM_CERT_PATH "/user/app/user/certcfg/" + +static void *Pkcs7Calloc(size_t nmemb, size_t size) +{ +#if (RUNNING_BOARD == LITE_WEARABLE) + void *ptr = PSRAM_Malloc(nmemb * size); + if (ptr == NULL) { + return NULL; + } + (void)memset_s(ptr, nmemb * size, 0, nmemb * size); + return ptr; +#else + return calloc(nmemb, size); +#endif +} + +static void Pkcs7Free(void *ptr) +{ +#if (RUNNING_BOARD == LITE_WEARABLE) + PSRAM_Free(ptr); +#else + free(ptr); +#endif +} + +#ifdef MARKET_ENABLE +#define DIALMARKET_PUBKEY_PATH "/user/dialpubkey" +/* hardcoded public key */ +static const char ROOT_CA_OEM_PUBKEY_IN_PEM[] = + "-----BEGIN PUBLIC KEY-----\r\n" + "MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAvnjlpcsSvEOhMfYwrW/Y\r\n" + "ExDmXL47SkbomiorGtdF63J2Vkgs2/HTxhUKBkIvSPbGRTR+io8rAo2J3oz1U48m\r\n" + "+M/+yIszIYC2s+tW64v8NuxLwMFFeg7+cud07/FwfJYYIRvyDQVduwV0VwvkTQy+\r\n" + "4/n5m+zJEHNheCakEEmFXn7vXUzxlSVSji5cHbGZ2ZzdmettLMc88tv/Kq8X3rgM\r\n" + "KQkngVylO4p93UvzY9hIAh9heL5VWMVOj241p3RojavIofODIeF7Vti2DjJjvbPW\r\n" + "igV0M9C0wLlZzMTQwoZbZT8mKsHkXW3XdTgc8ccD7RioeQa9MOlLKFbnJQLYNKr+\r\n" + "WsGDTFO2iHQmRAIGGuvWnxZIGS5Ho+ZUntdIYAvH8ww+36eFOwNp5cb1/ZjZmQ4c\r\n" + "p0zTw3zF8mSEieToMgIgz19wc9hvYgMPLlZpzFZklg8tJenJvcNpk5/3saEmpV6R\r\n" + "gGZ0IrmT/5h3Z/49W86Dv3b2ro4zb/sqtLufDqGoF3IDAgMBAAE=\r\n" + "-----END PUBLIC KEY-----\r\n"; + +static const unsigned char g_dialRootCertInPem[] = + "-----BEGIN CERTIFICATE-----\r\n" + "MIIEsTCCAxmgAwIBAgIUdJ4u/0ct0XJHZphCzmBQQddboC4wDQYJKoZIhvcNAQEL\r\n" + "BQAwaDELMAkGA1UEBhMCQ04xETAPBgNVBAgMCFNoZW56aGVuMREwDwYDVQQHDAhT\r\n" + "aGVuemhlbjEPMA0GA1UECgwGSFRMaW5rMQ8wDQYDVQQLDAZIVExpbmsxETAPBgNV\r\n" + "BAMMCEhUTGlua0NBMB4XDTI1MDQyNzA2NDkwN1oXDTM1MDQyNTA2NDkwN1owaDEL\r\n" + "MAkGA1UEBhMCQ04xETAPBgNVBAgMCFNoZW56aGVuMREwDwYDVQQHDAhTaGVuemhl\r\n" + "bjEPMA0GA1UECgwGSFRMaW5rMQ8wDQYDVQQLDAZIVExpbmsxETAPBgNVBAMMCEhU\r\n" + "TGlua0NBMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAytceDkYIIn2P\r\n" + "340TG6+3yI4NhauO7IoXDI74w3CXpqFG40F2h42IKnDLsDznGKMyaRglsab09K1m\r\n" + "/yrVomrH2/e1EpMaATiKIJFkEijSjo0/EGqYeT1q59tyXdkgl/VLV04Yh8ra5lU8\r\n" + "nVog/Lk02GLhoTVttMQOA2dn3muaLzjuBHEjfAisfubP+mxE1e7/P6E2ZD5D8J2i\r\n" + "XoMSDTO6FwZwNBtTnrTu11z1h5bRQ6jPU3fAWxcfThjR/InocTtS4OlpKNuPlnOt\r\n" + "PpS+j0DVD+UJKR3wPEXSpxwBVveSJB7NsCMIuAM9urTmhzJzcSu9pKKzb6r22xBx\r\n" + "HaNQ6g+rX6vCCHnT/vUlqscyrKxnC3DwEqzK2PByvAGaMDfB6co/nyncYmQ0eIz+\r\n" + "8Px+xoLcFQ6qfyHBlj81FHvkM5R/TprruGUUvWkTySQJnLuRY7aEqmFWQAKXYppK\r\n" + "G6ZmgnDYiV2vwpsdR6TbVomdmpIV7r0Vp8hs1vVRaZHOJoJdNrynAgMBAAGjUzBR\r\n" + "MB0GA1UdDgQWBBR6KC9wRu9J6A1Fa86FoLNVgSvYMzAfBgNVHSMEGDAWgBR6KC9w\r\n" + "Ru9J6A1Fa86FoLNVgSvYMzAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUA\r\n" + "A4IBgQDB/QGEdrz/bGpmHBca32oWYmeI4OSGZSjoBdzg54tI0TzncrQTduzSYTLM\r\n" + "8bl3HExDlZXR/wqMlfqftNctlHKRUpX3K0A78M3j2xdBu5AoeDI4Xis7AkWTeo4U\r\n" + "6EQYtZU1rY6RgX95GsMPyMtbEwB+xiUM8w2gf8rhTLt6iotDU6ErUh6qLS7zqQOJ\r\n" + "0ulmF9g9/bLcyfaVeXdxVL1+Ggw2jIpxkqO4XjeuUNj/1FrMmiZdKQAdny5aNEf4\r\n" + "MZ9IWd1WNgSOtbg/Csf7m55yOCJjUr3QteE1pRJoMAw0mw9GXEZkndRX27Sl6wvW\r\n" + "xeD9niKvD5dG7vg/dzSJNUBqL7dOyNezyWXJIlxXMG24MuWMe7GbBBbxdatEXs1E\r\n" + "fT/P6O9ffghZbd7q5Cm3pC/xfMtpPl1sV4OeDzIzs2j5Fvc7LXTePT60bbFLe5WB\r\n" + "yPLVWeOJrMxWjrppi8O7cVBo/uhWopV14vbawJ970flrgRH6/dm50P/VHQ7ktAZe\r\n" + "ZVFOoMU=\r\n" + "-----END CERTIFICATE-----\r\n"; + +#define PUB_KEY_SIZE 65 +#define SHARED_SECRET_SIZE 32 +#define UT_NV_MAX_LENGTH 4060 +#define CHUNK_SIZE (1024 * 4) // Each HASH update processes 4KB +#define SHA256_HASH_SIZE 32 +#define RSA3072_SIG_SIZE 384 +#define PUB_KEY_FILE_FULL_NAME_LEN 256 +#define ECC_PEN_KEY_LEN 256 +#define TARGET_PEM ".pem" + +typedef struct { + mbedtls_ecp_group grp; // Elliptic curve group (including curve parameters) + mbedtls_mpi d; // ECC private key + mbedtls_ecp_point Q; // ECC public key + unsigned char pubKey[PUB_KEY_SIZE]; + size_t pubKeyLen; + unsigned char workKey[SHARED_SECRET_SIZE]; + unsigned char noise[NOISE_SIZE]; +} EcdhEntity; + +typedef struct { + mbedtls_cipher_context_t *ctx; + const unsigned char *key; + const unsigned char *iv; + const unsigned char *input; + size_t ilen; + unsigned char *output; + size_t *olen; + int32_t paddingMode; +} AesParams; + +const uint16_t NV_KEY_ID = NV_ID_SECURE_DIAL; + +int32_t PKCS7_SaveKeyToNv(unsigned char *pem_buffer, uint32_t pem_bufferLen, uint16_t keyId) +{ + int32_t ret = 0; + nv_key_attr_t attr = {0, 1, 0, 0}; + ret = uapi_nv_write_with_attr(keyId, pem_buffer, pem_bufferLen, &attr, NULL); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to write key to nv."); + return PKCS7_SAVE_PUB_KEY_FAIL; + } + return ret; +} + +int32_t PKCS7_GetKeyFromNv(uint16_t keyId, uint8_t *data) +{ + int32_t ret = 0; + uint16_t k_length = 0; + nv_key_attr_t attr = {0, 1, 0, 0}; + ret = uapi_nv_read_with_attr(keyId, UT_NV_MAX_LENGTH, &k_length, data, &attr); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to read key from nv."); + return PKCS7_GET_PUB_KEY_FAIL; + } + return ret; +} + +int32_t InitDrbg(mbedtls_ctr_drbg_context *drbg, mbedtls_entropy_context *entropy) +{ + const char *pers = "ECDH_Negotiation"; + mbedtls_entropy_init(entropy); + mbedtls_ctr_drbg_init(drbg); + if (mbedtls_ctr_drbg_seed(drbg, mbedtls_entropy_func, entropy, (const uint8_t *)pers, strlen(pers)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_ctr_drbg_seed failed"); + return PKCS7_INVALID_PARAM; + } + return 0; +} + +int32_t InitEcdhEntity(EcdhEntity *entity, mbedtls_ctr_drbg_context *drbg) +{ + int32_t ret = 0; + + // Initialize all cryptographic objects + mbedtls_ecp_group_init(&entity->grp); + mbedtls_mpi_init(&entity->d); + mbedtls_ecp_point_init(&entity->Q); + entity->pubKeyLen = 0; + + // 1. Loading curve MBEDTLS-EPC_SP_BP256R1 + ret = mbedtls_ecp_group_load(&entity->grp, MBEDTLS_ECP_DP_BP256R1); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_ecp_group_load failed: -0x%04X\n", -ret); + return ret; + } + + // 2. Generate key pairs + ret = mbedtls_ecdh_gen_public( + &entity->grp, &entity->d, &entity->Q, + mbedtls_ctr_drbg_random, drbg); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_ecdh_gen_public failed: -0x%04X\n", -ret); + return ret; + } + return 0; +} + +// Triple HKDF derived function (using synchronized salt values) +int32_t TripleHkdfDerive(const unsigned char *sharedSecret, size_t secretLen, + const unsigned char sals[SALT_INFO_POOL_ROWS * NOISE_SIZE], unsigned char *finalKey, size_t keyLen) +{ + int32_t ret; + const mbedtls_md_info_t *md = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); + unsigned char intermediate_key[AES_KEY_LEN]; + + // First round of HKDF: salt1 + if ((ret = mbedtls_hkdf(md, sals, NOISE_SIZE, sharedSecret, secretLen, + NULL, 0, intermediate_key, AES_KEY_LEN)) != 0) { + return ret; + } + + // Second round HKDF: salt2, Attach protocol identifier to info2 + const char *info2 = "HKDF-Round2"; + // IKM is the output of the previous round, Covering the intermediate key + if ((ret = mbedtls_hkdf(md, sals + NOISE_SIZE, NOISE_SIZE, intermediate_key, AES_KEY_LEN, + (const unsigned char *)info2, strlen(info2), intermediate_key, AES_KEY_LEN)) != 0) { + return ret; + } + + // Third round HKDF: salt3, Fixed protocol identification + const char *info3 = "AES128-CBC-Key"; + if ((ret = mbedtls_hkdf(md, sals + NOISE_SIZE + NOISE_SIZE, NOISE_SIZE, intermediate_key, AES_KEY_LEN, + (const unsigned char *)info3, strlen(info3), finalKey, keyLen)) != 0) { + return ret; + } + memset_s(intermediate_key, AES_KEY_LEN, 0, AES_KEY_LEN); + return 0; +} + +int32_t ComputeSharedSecret(EcdhEntity *local, EcdhEntity *peer, mbedtls_ctr_drbg_context *drbg, + unsigned char pubKeyFileName[PUBLIC_KEY_FILE_LEN], mbedtls_entropy_context *entropy) +{ + int32_t ret; + mbedtls_mpi z; + mbedtls_mpi_init(&z); + unsigned char sharedSecret[SHARED_SECRET_SIZE] = {0}; + // 1. Analyze the public key of the opposite end + mbedtls_ecp_point peer_Q; + mbedtls_ecp_point_init(&peer_Q); + ret = mbedtls_ecp_point_read_binary(&local->grp, &peer_Q, peer->pubKey, peer->pubKeyLen); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_ecp_point_read_binary failed: -0x%04X\n", -ret); + goto cleanup; + } + // 2. Calculate shared key + ret = mbedtls_ecdh_compute_shared(&local->grp, &z, &peer_Q, &local->d, mbedtls_ctr_drbg_random, drbg); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_ecdh_compute_shared failed: -0x%04X\n", -ret); + goto cleanup; + } + unsigned char saltInfoPool[SALT_INFO_POOL_ROWS * NOISE_SIZE] = {0}; + mbedtls_ctr_drbg_random(drbg, saltInfoPool, NOISE_SIZE * SALT_INFO_POOL_ROWS); + /* + * Optimizing the performance of converting each byte into two hexadecimal characters + * using the lookup table method. + */ + const char hexTable[] = "0123456789ABCDEF"; + for (int i = 0; i < SALT_INFO_POOL_ROWS * NOISE_SIZE; i++) { + pubKeyFileName[i * 2] = hexTable[saltInfoPool[i] >> 4]; // Move 4 positions to the right + pubKeyFileName[i * 2 + 1] = hexTable[saltInfoPool[i] & 0x0F]; + } + ret = memcpy_s(pubKeyFileName + SALT_INFO_POOL_ROWS * NOISE_SIZE * 2, strlen(TARGET_PEM), TARGET_PEM, + strlen(TARGET_PEM)); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "memcpy_s failed: -0x%04X\n", -ret); + goto cleanup; + } + pubKeyFileName[PUBLIC_KEY_FILE_LEN - 1] = '\0'; + // 3. Convert to byte stream + ret = mbedtls_mpi_write_binary(&z, sharedSecret, SHARED_SECRET_SIZE); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_mpi_write_binary failed: -0x%04X\n", -ret); + goto cleanup; + } + // HKDF derived working key (parameters must be consistent with the counterpart) + if ((ret = TripleHkdfDerive(sharedSecret, sizeof(sharedSecret), saltInfoPool, + local->workKey, sizeof(local->workKey))) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Three failed HKDF attempts: -0x%04x\n", -ret); + goto cleanup; + } +cleanup: + mbedtls_mpi_free(&z); + mbedtls_ecp_point_free(&peer_Q); + memset_s(sharedSecret, sizeof(sharedSecret), 0, sizeof(sharedSecret)); + return ret; +} + +// Extract private key as byte array +int32_t GetPrivateKey(EcdhEntity *entity, unsigned char *eccPrivKey, size_t *eccPrivKeyLen) +{ + if (mbedtls_mpi_size(&entity->d) > *eccPrivKeyLen) { + return MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL; + } + + *eccPrivKeyLen = mbedtls_mpi_size(&entity->d); + return mbedtls_mpi_write_binary(&entity->d, eccPrivKey, *eccPrivKeyLen); +} + +int32_t CreateCubdirAndFile(const char *subdir, const char *filename, const void *data, size_t size) +{ + // 1. Create the client's public key directory and file for the first boot, and grant the file 0755 permission + if (mkdir(subdir, 0755) != 0) { + if (errno != EEXIST) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to create subdirectories!"); + return PKCS7_FILE_OPERATION_FAIL; + } + } + + // 2. Build a complete file path + char fullpath[PUB_KEY_FILE_FULL_NAME_LEN]; + int32_t ret = snprintf_s(fullpath, sizeof(fullpath), sizeof(fullpath) - 1, "%s/%s", subdir, filename); + if (ret < 0 || ret >= sizeof(fullpath)) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Path truncated!"); + return PKCS7_INVALID_PARAM; + } + // 3. Create and write files + FILE *fp = fopen(fullpath, "wb"); + if (!fp) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to create file"); + return PKCS7_FILE_OPERATION_FAIL; + } + + if (data && size > 0) { + if (fwrite(data, 1, size, fp) != size) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Fail to write to file!"); + fclose(fp); + return PKCS7_FILE_OPERATION_FAIL; + } + } + + fclose(fp); + return 0; +} + +// Check if there is a. pem file in the directory +bool CheckPemExists(const char *dirPath) +{ + DIR *dir = opendir(dirPath); + if (!dir) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Fail to open dir:%s!", dirPath); + return false; + } + + struct dirent *entry; + bool hasPem = false; + while ((entry = readdir(dir)) != NULL) { + if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) { + continue; + } + // Check file extension + const char *ext = strrchr(entry->d_name, '.'); + if (ext && strcmp(ext, TARGET_PEM) == 0) { + hasPem = true; + break; + } + } + + closedir(dir); + return hasPem; +} + +static int32_t GetClientECCPubKey(EcdhEntity *entity, unsigned char *clientPubKey) +{ + // Convert the public key to PEM format and write it to a file + mbedtls_pk_context pk; + mbedtls_pk_init(&pk); + + // Bind ECC key context + int32_t ret = mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_pk_setup failed: -0x%04X\n", -ret); + goto cleanup; + } + + // Copy curve parameters and public key to pk context + mbedtls_ecp_keypair *ec_key = mbedtls_pk_ec(pk); + ret = mbedtls_ecp_group_copy(&ec_key->MBEDTLS_PRIVATE(grp), &entity->grp); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_ecp_group_copy failed: -0x%04X\n", -ret); + goto cleanup; + } + + ret = mbedtls_ecp_copy(&ec_key->MBEDTLS_PRIVATE(Q), &entity->Q); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_ecp_copy failed: -0x%04X\n", -ret); + goto cleanup; + } + + // Generate PEM format public key + ret = mbedtls_pk_write_pubkey_pem(&pk, clientPubKey, ECC_PEN_KEY_LEN); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_pk_write_pubkey_pem failed: -0x%04X\n", -ret); + goto cleanup; + } +cleanup: + mbedtls_pk_free(&pk); + return ret; +} + +int32_t PKCS7_GenerateECCKeypair() +{ + unsigned char clientPubKey[ECC_PEN_KEY_LEN]; + EcdhEntity client = {0}; + EcdhEntity peer = {0}; + if (CheckPemExists(DIALMARKET_PUBKEY_PATH)) { + HILOG_INFO(HILOG_MODULE_AAFWK, "The public key already exists!"); + return 0; + } + unsigned char pubKeyFileName[PUBLIC_KEY_FILE_LEN] = {0}; + // ECDH negotiation + mbedtls_ctr_drbg_context drbg; + mbedtls_entropy_context entropy; + int32_t ret = InitDrbg(&drbg, &entropy); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to InitDrbg!\n"); + return ret; + } + // 1. Generate client key pairs + ret = InitEcdhEntity(&client, &drbg); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to init ecdh entity!\n"); + return ret; + } + // Server public key + const uint8_t server_pub_key[PUB_KEY_SIZE] = { + 0x04, 0x67, 0x6E, 0xFF, 0x58, 0x0E, 0xB2, 0x64, 0x79, 0x40, 0x29, 0x9C, 0xBB, 0x1A, 0xE6, + 0x22, 0xA2, 0x62, 0x8F, 0x06, 0xDA, 0x74, 0x0C, 0xAC, 0x88, 0x1D, 0x8D, 0x40, 0xBE, 0xB8, + 0xC9, 0xE3, 0x79, 0x9F, 0x32, 0x66, 0x5D, 0xEC, 0xF1, 0xBA, 0xCF, 0x03, 0x10, 0x1B, 0x80, + 0xD0, 0x8B, 0xF8, 0xF0, 0x56, 0x01, 0x74, 0x30, 0xC3, 0x20, 0x18, 0x5B, 0x83, 0x5F, 0xA4, + 0xA0, 0x90, 0x6E, 0x53, 0x89 + }; + ret = memcpy_s(peer.pubKey, PUB_KEY_SIZE, server_pub_key, PUB_KEY_SIZE); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to init ecdh entity!\n"); + return ret; + } + peer.pubKeyLen = PUB_KEY_SIZE; + ret = ComputeSharedSecret(&client, &peer, &drbg, pubKeyFileName, &entropy); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to compute shared secret!\n"); + goto cleanup; + } + ret = PKCS7_SaveKeyToNv(client.workKey, AES_KEY_LEN, NV_KEY_ID); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to PKCS7_SaveKeyToNv!\n"); + goto cleanup; + } + ret = GetClientECCPubKey(&client, clientPubKey); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to GetClientECCPubKey!\n"); + goto cleanup; + } + if (CreateCubdirAndFile(DIALMARKET_PUBKEY_PATH, pubKeyFileName, clientPubKey, strlen(clientPubKey)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Public key write failed!"); + ret = MBEDTLS_ERR_PK_FILE_IO_ERROR; + goto cleanup; + } + +cleanup: + mbedtls_ecp_group_free(&client.grp); + mbedtls_mpi_free(&client.d); + mbedtls_ecp_point_free(&client.Q); + memset_s(&client, sizeof(client), 0, sizeof(client)); + mbedtls_ctr_drbg_free(&drbg); + mbedtls_entropy_free(&entropy); + return ret; +} + +static int32_t verifyCertChain(FILE *fp, const MetadataStruct *meta, mbedtls_x509_crt *certChain) +{ + int32_t ret = 0; + uint32_t flags = 0; + unsigned char *appCert = NULL; + mbedtls_x509_crt rootCert; + mbedtls_x509_crt_init(&rootCert); + if ((ret = mbedtls_x509_crt_parse(&rootCert, g_dialRootCertInPem, sizeof(g_dialRootCertInPem))) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Root certificate parsing failed: -0x%04X!", -ret); + goto cleanup; + } + + // Read and parse application certificates + appCert = Pkcs7Calloc(meta->appCertLen + 1, sizeof(char)); + if (appCert == NULL) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "malloc failed!"); + ret = PKCS7_MEMORY_EXHAUST; + goto cleanup; + } + fseek(fp, meta->sigOffset + meta->sigLen, SEEK_SET); + if (fread(appCert, 1, meta->appCertLen, fp) != meta->appCertLen) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Read app cert failed!"); + ret = PKCS7_FILE_OPERATION_FAIL; + goto cleanup; + } + appCert[meta->appCertLen] = '\0'; + if ((ret = mbedtls_x509_crt_parse(certChain, appCert, meta->appCertLen + 1)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Application certificate parsing failed: -0x%04X!", -ret); + goto cleanup; + } + // Read and parse intermediate certificates + unsigned char *interCert = Pkcs7Calloc(meta->intermediateCertLen + 1, sizeof(char)); + if (interCert == NULL) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "malloc for intermediate cert failed!"); + ret = PKCS7_MEMORY_EXHAUST; + goto cleanup; + } + fseek(fp, meta->sigOffset + meta->sigLen + meta->appCertLen, SEEK_SET); + if (fread(interCert, 1, meta->intermediateCertLen, fp) != meta->intermediateCertLen) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Intermediate certificate read failed!"); + ret = PKCS7_FILE_OPERATION_FAIL; + goto cleanup; + } + interCert[meta->intermediateCertLen] = '\0'; + if ((ret = mbedtls_x509_crt_parse(certChain, interCert, meta->intermediateCertLen + 1)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Intermediate certificate parsing failed: -0x%04X!", -ret); + goto cleanup; + } + // Verify certificate chain + if ((ret = mbedtls_x509_crt_verify(certChain, &rootCert, NULL, NULL, &flags, NULL, NULL)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Certificate chain verification failed: -0x%04X!", -ret); + } + +cleanup: + if (appCert) { + Pkcs7Free(appCert); + appCert = NULL; + } + if (interCert) { + Pkcs7Free(interCert); + interCert = NULL; + } + mbedtls_x509_crt_free(&rootCert); + return ret; +} + +int32_t AesCrypt(const AesParams *params) +{ + if (params == NULL || params->ctx == NULL || params->key == NULL || params->iv == NULL || params->input == NULL || + params->output == NULL || params->olen == NULL) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Invalid AES parameters"); + return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA; + } + + int32_t ret = 0; + if ((ret = mbedtls_cipher_reset(params->ctx)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Cipher reset failed: -0x%04X", -ret); + return ret; + } + // 128 is the length of key for AES128 + if ((ret = mbedtls_cipher_setkey(params->ctx, params->key, 128, MBEDTLS_DECRYPT)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Set key failed: -0x%04X", -ret); + return ret; + } + + if ((ret = mbedtls_cipher_set_padding_mode(params->ctx, params->paddingMode)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Set padding failed: -0x%04X", -ret); + return ret; + } + + if ((ret = mbedtls_cipher_crypt(params->ctx, params->iv, AES_KEY_LEN, params->input, params->ilen, + params->output, params->olen)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Cryption failed: -0x%04X", -ret); + } + return ret; +} + +static int32_t VerifySignature(FILE *fp, const MetadataStruct *meta, mbedtls_x509_crt *certChain, unsigned char *hash) +{ + int32_t ret = 0; + unsigned char *sigBuf = Pkcs7Calloc(meta->sigLen, sizeof(char)); + if (sigBuf == NULL) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "memory allocation failed!"); + return PKCS7_MEMORY_EXHAUST; + } + + // Read signature data + fseek(fp, meta->sigOffset, SEEK_SET); + if (fread(sigBuf, 1, meta->sigLen, fp) != meta->sigLen) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Signature reading failed!"); + ret = PKCS7_FILE_OPERATION_FAIL; + goto exit; + } + // verify signature + mbedtls_pk_rsassa_pss_options pss_options = { + .mgf1_hash_id = MBEDTLS_MD_SHA256, + .expected_salt_len = SHA256_HASH_SIZE // Must be consistent with the SaltLength on the Java side + }; + // Pass PSS parameters when calling the verification interface + ret = mbedtls_pk_verify_ext(MBEDTLS_PK_RSASSA_PSS, &pss_options, &certChain->pk, MBEDTLS_MD_SHA256, + hash, SHA256_HASH_SIZE, sigBuf, meta->sigLen); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Verification of dial signature failed!, ret:%d", ret); + } +exit: + if (sigBuf != NULL) { + Pkcs7Free(sigBuf); + sigBuf = NULL; + } + return ret; +} + +static int32_t VerifySignatureStream(FILE *fp, const MetadataStruct *meta, mbedtls_x509_crt *certChain, + const unsigned char *restoredData, size_t restoredLen) +{ + int32_t ret = 0; + unsigned char hash[SHA256_HASH_SIZE] = {0}; + mbedtls_md_context_t mdCtx; + size_t unencryptedLen = 0; + size_t processed = 0; + unsigned char *buffer = Pkcs7Calloc(CHUNK_SIZE, sizeof(char)); + if (buffer == NULL) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "memory allocation failed!"); + return PKCS7_MEMORY_EXHAUST; + } + size_t baseSize = FRONT_FIXED_SIZE + meta->dialViewCount; + unencryptedLen = meta->originalLen - baseSize; + mbedtls_md_init(&mdCtx); + mbedtls_md_setup(&mdCtx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 0); + mbedtls_md_starts(&mdCtx); + size_t processedRestored = 0; + fseek(fp, meta->encryptedLen - meta->padLen, SEEK_SET); + // 1. Process decrypted encrypted data blocks (including padding) + while (processedRestored < restoredLen) { + // Logic for Filling Buffer Zones + size_t remainingRestored = restoredLen - processedRestored; + size_t copySize = (remainingRestored > CHUNK_SIZE) ? CHUNK_SIZE : remainingRestored; + // Copy decrypted data to the buffer + ret = memcpy_s(buffer, copySize, restoredData + processedRestored, copySize); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Verification of dial signature failed!, ret:%d", ret); + ret = PKCS7_MEMORY_EXHAUST; + goto exit; + } + // If the buffer is not filled, try supplementing data from the file + if (copySize < CHUNK_SIZE) { + size_t need_read = CHUNK_SIZE - copySize; + size_t actually_read = fread(buffer + copySize, 1, need_read, fp); + copySize += actually_read; + } + + // Update hash calculation + mbedtls_md_update(&mdCtx, buffer, copySize); + processedRestored += copySize; + + // If it exceeds the original data range, jump out + if (processedRestored > restoredLen) { + break; + } + } + + // 2. Process remaining unencrypted data + unencryptedLen -= processedRestored - restoredLen; + if (unencryptedLen > 0) { + while (processed < unencryptedLen) { + size_t remaining = unencryptedLen - processed; + size_t chunk = (remaining > CHUNK_SIZE) ? CHUNK_SIZE : remaining; + + // Read unencrypted data blocks directly from files + if (fread(buffer, 1, chunk, fp) != chunk) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to read unencrypted data!"); + ret = PKCS7_FILE_OPERATION_FAIL; + goto exit; + } + mbedtls_md_update(&mdCtx, buffer, chunk); + processed += chunk; + } + // Verify if it has been fully read + if (processed != unencryptedLen) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Unencrypted data length mismatch!", processed, unencryptedLen); + ret = PKCS7_INVALID_PARAM; + goto exit; + } + } + // Complete hash calculation + mbedtls_md_finish(&mdCtx, hash); + + ret = VerifySignature(fp, meta, certChain, hash); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "VerifySignature failed!"); + } +exit: + mbedtls_md_free(&mdCtx); + if (buffer != NULL) { + Pkcs7Free(buffer); + buffer = NULL; + } + return ret; +} + +static int32_t DecryptAesKey(mbedtls_cipher_context_t *ctx, const MetadataStruct *meta, const uint8_t *eccWorkKey, + unsigned char *aesKey) +{ + size_t olen = AES_KEY_LEN; + AesParams params = { + .ctx = ctx, + .key = eccWorkKey, + .iv = meta->iv2, + .input = meta->password, + .ilen = sizeof(meta->password), + .output = aesKey, + .olen = &olen, + .paddingMode = MBEDTLS_PADDING_NONE + }; + int32_t ret = AesCrypt(¶ms); + if (ret == 0 && olen != AES_KEY_LEN) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Invalid AES key length: %zu", olen); + return PKCS7_INVALID_PARAM; + } + return ret; +} + +static int32_t ReadAndPrepareData(FILE *fp, const MetadataStruct *meta, unsigned char **encryptedData, size_t *dataLen) +{ + *encryptedData = Pkcs7Calloc(meta->encryptedLen, 1); + if (*encryptedData == NULL) { + return PKCS7_MEMORY_EXHAUST; + } + + fseek(fp, 0, SEEK_SET); + size_t readLen = fread(*encryptedData, 1, meta->encryptedLen - meta->padLen, fp); + if (readLen != meta->encryptedLen - meta->padLen) { + Pkcs7Free(*encryptedData); + return PKCS7_FILE_OPERATION_FAIL; + } + + if (memcpy_s(*encryptedData + readLen, meta->padLen, meta->padData, meta->padLen) != 0) { + Pkcs7Free(*encryptedData); + return PKCS7_MEMORY_EXHAUST; + } + + *dataLen = meta->encryptedLen; + return 0; +} + +int32_t PKCS7_VerifyAndDecrypt(FILE *fp, bool firstLoad, MetadataStruct *meta, unsigned char *restoredBuf, + uint32_t originalLen) +{ + int32_t ret = 0; + unsigned char aesKey[AES_KEY_LEN] = {0}; + uint8_t eccWorkKey[AES_KEY_LEN] = {0}; + mbedtls_x509_crt *certChain = NULL; + mbedtls_cipher_context_t ctx; + unsigned char *encryptedData = NULL; + size_t dataLen = 0; + + // Parameter validation + if (fp == NULL || meta == NULL || restoredBuf == NULL || originalLen < meta->encryptedLen) { + return PKCS7_INVALID_PARAM; + } + + mbedtls_cipher_init(&ctx); + const mbedtls_cipher_info_t *info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_CBC); + + // Setup cipher context + if ((ret = mbedtls_cipher_setup(&ctx, info)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Cipher setup failed: -0x%04X", -ret); + goto cleanup; + } + + // ECC key handling + if (meta->pubKeyType == ENC_TYPE_ECC) { + if ((ret = PKCS7_GetKeyFromNv(NV_KEY_ID, eccWorkKey)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Get ECC key failed: %d", ret); + goto cleanup; + } + if ((ret = DecryptAesKey(&ctx, meta, eccWorkKey, aesKey)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Decrypt AES key failed: %d", ret); + goto cleanup; + } + } + + // Read and decrypt data + if ((ret = ReadAndPrepareData(fp, meta, &encryptedData, &dataLen)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Read data failed: %d", ret); + goto cleanup; + } + + size_t olen = meta->encryptedLen; + AesParams decryptParams = { + .ctx = &ctx, + .key = aesKey, + .iv = meta->iv1, + .input = encryptedData, + .ilen = dataLen, + .output = restoredBuf, + .olen = &olen, + .paddingMode = MBEDTLS_PADDING_PKCS7 + }; + if ((ret = AesCrypt(&decryptParams)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Decrypt failed: %d", ret); + goto cleanup; + } + + // Signature verification for first load + if (firstLoad) { + if ((certChain = Pkcs7Calloc(1, sizeof(mbedtls_x509_crt))) == NULL) { + ret = PKCS7_MEMORY_EXHAUST; + goto cleanup; + } + mbedtls_x509_crt_init(certChain); + + if ((ret = verifyCertChain(fp, meta, certChain)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Cert chain failed: %d", ret); + goto cleanup; + } + + if ((ret = VerifySignatureStream(fp, meta, certChain, restoredBuf, olen)) != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Signature failed: %d", ret); + goto cleanup; + } + } + +cleanup: + if (certChain != NULL) { + mbedtls_x509_crt_free(certChain); + free(certChain); + } + if (encryptedData != NULL) { + Pkcs7Free(encryptedData); + } + mbedtls_cipher_free(&ctx); + memset_s(aesKey, AES_KEY_LEN, 0, AES_KEY_LEN); + memset_s(eccWorkKey, AES_KEY_LEN, 0, AES_KEY_LEN); + return ret; +} + +static int32_t VerifyHashList() +{ + int32_t rc = 0; + const char *hashListFile = OEM_CERT_PATH"root_cert_hash_list.bin"; + const char *signatureFile = OEM_CERT_PATH"hash_list_sign.bin"; + unsigned char hash[SHA256_HASH_SIZE]; + mbedtls_pk_context pk; + FILE *file = fopen(hashListFile, "rb"); + if (!file) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to open file to verify."); + return PKCS7_VERIFY_FAIL; + } + rc = fseek(file, 0, SEEK_END); + if (rc != 0) { + rc = PKCS7_HAS_NO_SIGNER_CRT; + goto exit; + } + long fileSize = ftell(file); + rc = fseek(file, 0, SEEK_SET); + if (rc != 0 || fileSize > INT_MAX) { + rc = PKCS7_HAS_NO_SIGNER_CRT; + goto exit; + } + unsigned char *fileData = Pkcs7Calloc(fileSize, sizeof(char)); + if (!fileData) { + rc = PKCS7_HAS_NO_SIGNER_CRT; + goto exit; + } + int32_t fileLen = fread(fileData, 1, fileSize, file); + if (fileLen != fileSize) { + rc = PKCS7_HAS_NO_SIGNER_CRT; + goto exit; + } + mbedtls_pk_init(&pk); + if ((rc = mbedtls_pk_parse_public_key(&pk, (const unsigned char *)ROOT_CA_OEM_PUBKEY_IN_PEM, + strlen(ROOT_CA_OEM_PUBKEY_IN_PEM) + 1)) != 0) { + rc = PKCS7_HAS_NO_SIGNER_CRT; + goto exit; + } + mbedtls_rsa_context *rsa = mbedtls_pk_rsa(pk); + mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA256); + FILE *sigFile = fopen(signatureFile, "rb"); + if (!sigFile) { + rc = PKCS7_HAS_NO_SIGNER_CRT; + goto exit; + } + unsigned char *signature = Pkcs7Calloc(RSA3072_SIG_SIZE, sizeof(char)); + if (!signature) { + rc = PKCS7_HAS_NO_SIGNER_CRT; + goto exit; + } + if (fread(signature, 1, RSA3072_SIG_SIZE, sigFile) != RSA3072_SIG_SIZE) { + rc = PKCS7_VERIFY_FAIL; + goto exit; + } + mbedtls_sha256(fileData, fileSize, hash, 0); + rc = mbedtls_pk_verify(&pk, MBEDTLS_MD_SHA256, hash, SHA256_HASH_SIZE, signature, RSA3072_SIG_SIZE); + if (rc != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "mbedtls_pk_verify failed! return %d\n", rc); + goto exit; + } +exit: + if (file) { + fclose(file); + file = NULL; + } + if (sigFile) { + fclose(sigFile); + sigFile = NULL; + } + if (fileData) { + Pkcs7Free(fileData); + fileData = NULL; + } + if (signature) { + Pkcs7Free(signature); + signature = NULL; + } + mbedtls_pk_free(&pk); + return rc; +} +#endif /* valid digest alg now: sha256 sha384 sha512 */ static bool InvalidDigestAlg(const mbedtls_asn1_buf *alg) @@ -111,17 +1012,12 @@ static bool InvalidDigestAlg(const mbedtls_asn1_buf *alg) MBEDTLS_OID_CMP(MBEDTLS_OID_DIGEST_ALG_SHA512, alg); } -/* - * ContentInfo ::= SEQUENCE { - * contentType ContentType, - * content [0] EXPLICIT ANY DEFINED BY contentType OPTIONAL } - */ -static int GetContentInfoType(unsigned char **p, const unsigned char *end, - mbedtls_asn1_buf *contentType, bool *hasContent) +static int32_t GetContentInfoType(unsigned char **p, const unsigned char *end, mbedtls_asn1_buf *contentType, + bool *hasContent) { size_t seqLen = 0; size_t len = 0; - int rc; + int32_t rc; rc = mbedtls_asn1_get_tag(p, end, &seqLen, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE); if (rc) { @@ -137,44 +1033,24 @@ static int GetContentInfoType(unsigned char **p, const unsigned char *end, contentType->len = len; contentType->p = *p; *hasContent = (seqLen != len + (*p - start)); - *p += len; // pass the oid info to the real content location. + *p += len; /* pass the oid info to the real content location. */ - return rc; + return PKCS7_SUCC; } -static int GetContentLenOfContentInfo(unsigned char **p, const unsigned char *end, size_t *len) +static int32_t GetContentLenOfContentInfo(unsigned char **p, const unsigned char *end, size_t *len) { return mbedtls_asn1_get_tag(p, end, len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC); } -/* - * Version ::= INTEGER - */ -static int ParseSignerVersion(unsigned char **p, const unsigned char *end, SignerInfo *signer) +static int32_t ParseSignerVersion(unsigned char **p, const unsigned char *end, SignerInfo *signer) { return mbedtls_asn1_get_int(p, end, &signer->version); } -/* - * IssuerAndSerialNumber ::= SEQUENCE { - * issuer Name, - * serialNumber CertificateSerialNumber } - * - * Name ::= CHOICE { -- only one possibility for now -- - * rdnSequence RDNSequence } - * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName - * RelativeDistinguishedName ::= SET SIZE (1..MAX) OF AttributeTypeAndValue - * AttributeTypeAndValue ::= SEQUENCE { - * type AttributeType, - * value AttributeValue } - * AttributeType ::= OBJECT IDENTIFIER - * AttributeValue ::= ANY -- DEFINED BY AttributeType - * - * CertificateSerialNumber ::= INTEGER - */ -static int ParseSignerIssuerAndSerialNum(unsigned char **p, const unsigned char *end, SignerInfo *signer) +static int32_t ParseSignerIssuerAndSerialNum(unsigned char **p, const unsigned char *end, SignerInfo *signer) { - int rc; + int32_t rc; size_t len; rc = mbedtls_asn1_get_tag(p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE); @@ -199,43 +1075,22 @@ static int ParseSignerIssuerAndSerialNum(unsigned char **p, const unsigned char return rc; } -/* - * digestAlgorithm DigestAlgorithmIdentifier, - * DigestAlgorithmIdentifier ::= AlgorithmIdentifier - * AlgorithmIdentifier ::= SEQUENCE { -- defined in X509 - * algorithm OBJECT IDENTIFIER, - * parameters ANY DEFINED BY algorithm OPTIONAL } - * } - */ -static int ParseSignerDigestAlg(unsigned char **p, const unsigned char *end, SignerInfo *signer) +static int32_t ParseSignerDigestAlg(unsigned char **p, const unsigned char *end, SignerInfo *signer) { - int rc = mbedtls_asn1_get_alg_null(p, end, &signer->digestAlgId); + int32_t rc = mbedtls_asn1_get_alg_null(p, end, &signer->digestAlgId); if (rc) { return rc; } if (InvalidDigestAlg(&signer->digestAlgId)) { return PKCS7_INVALID_DIGEST_ALG; } - return rc; + return PKCS7_SUCC; } -/* - * authenticatedAttributes? [0] IMPLICIT Attributes OPTIONAL, - * - * maybe some attributes - * contentType, signingTime, messageDigest, unstructuredName - * each attribute is constructed by a SEQUENCE - * { - * OID, - * SET OF - * } - * here do not resolve the real content, just record the location. - */ -static int ParseSignerAuthAttr(unsigned char **p, const unsigned char *end, SignerInfo *signer) +static int32_t ParseSignerAuthAttr(unsigned char **p, const unsigned char *end, SignerInfo *signer) { - int rc; - size_t len; - + int32_t rc; + size_t len = 0; unsigned char *raw = *p; rc = mbedtls_asn1_get_tag(p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC); @@ -250,7 +1105,7 @@ static int ParseSignerAuthAttr(unsigned char **p, const unsigned char *end, Sign signer->authAttrRaw.p = raw; signer->authAttrRaw.len = len + tlLen; - return rc; + return PKCS7_SUCC; } /* @@ -267,19 +1122,10 @@ static bool InvalidDigestEncAlg(const mbedtls_x509_buf *alg) MBEDTLS_OID_CMP(MBEDTLS_OID_RSASSA_PSS, alg); } -/* - * digestEncryptionAlgorithm DigestEncryptionAlgorithmIdentifier, - * DigestEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier - * AlgorithmIdentifier ::= SEQUENCE { -- defined in X509 - * algorithm OBJECT IDENTIFIER, - * parameters ANY DEFINED BY algorithm OPTIONAL } - * } - * - */ -static int ParseSignerEncAlg(unsigned char **p, const unsigned char *end, SignerInfo *signer) +static int32_t ParseSignerEncAlg(unsigned char **p, const unsigned char *end, SignerInfo *signer) { - int rc; - mbedtls_asn1_buf params; + int32_t rc; + mbedtls_asn1_buf params = {0}; /* params not be used now */ rc = mbedtls_asn1_get_alg(p, end, &signer->digestEncAlgId, ¶ms); if (rc) { @@ -288,17 +1134,17 @@ static int ParseSignerEncAlg(unsigned char **p, const unsigned char *end, Signer if (InvalidDigestEncAlg(&signer->digestEncAlgId)) { return PKCS7_INVALID_SIGNING_ALG; } - return rc; + return PKCS7_SUCC; } /* * encryptedDigest EncryptedDigest, * EncryptedDigest ::= OCTET STRING */ -static int ParseSignerSignature(unsigned char **p, const unsigned char *end, SignerInfo *signer) +static int32_t ParseSignerSignature(unsigned char **p, const unsigned char *end, SignerInfo *signer) { - int rc; - size_t len; + int32_t rc; + size_t len = 0; rc = mbedtls_asn1_get_tag(p, end, &len, MBEDTLS_ASN1_OCTET_STRING); if (rc) { @@ -308,14 +1154,10 @@ static int ParseSignerSignature(unsigned char **p, const unsigned char *end, Sig signer->signature.len = len; signer->signature.p = *p; *p += len; - return rc; + return PKCS7_SUCC; } -/* This must be called after pkcs7 parsed - * OCTET STRING encode could be use primitive or constructed ? - * we use constructed here. - */ -static int GetSignerSignature(const SignerInfo *signer, unsigned char **sig, size_t *sigLen) +static int32_t GetSignerSignature(const SignerInfo *signer, unsigned char **sig, size_t *sigLen) { size_t len = signer->signature.len; unsigned char *buf = signer->signature.p; @@ -324,13 +1166,10 @@ static int GetSignerSignature(const SignerInfo *signer, unsigned char **sig, siz return PKCS7_SUCC; } -/* - * unauthenticatedAttributes [1] IMPLICIT Attributes OPTIONAL, - */ -static int ParseSignerUnAuthAttr(unsigned char **p, const unsigned char *end, SignerInfo *signer) +static int32_t ParseSignerUnAuthAttr(unsigned char **p, const unsigned char *end, SignerInfo *signer) { - int rc; - size_t len; + int32_t rc; + size_t len = 0; /* the optional unauth attr is not exist */ if (end - *p < 1) { @@ -344,133 +1183,83 @@ static int ParseSignerUnAuthAttr(unsigned char **p, const unsigned char *end, Si signer->unAuthAttr.len = len; signer->unAuthAttr.p = *p; *p += len; - return rc; + return PKCS7_SUCC; } -static int SerialCmp(const mbedtls_x509_buf *a, const mbedtls_x509_buf *b) +static int32_t SerialCmp(const mbedtls_x509_buf *a, const mbedtls_x509_buf *b) { if (a->len == b->len && memcmp(a->p, b->p, a->len) == 0) { return 0; } return -1; } -/* - * below three function is from mbedtls because mbedtls not provide interface - * of name compare. - */ + #define DIFF_NUM 32 -static int X509_MemcaseCmp(const void *s1, const void *s2, size_t len) +static bool IsLegitString(int32_t tag) { - size_t i; - unsigned char diff; - const unsigned char *n1 = s1; - const unsigned char *n2 = s2; - - for (i = 0; i < len; i++) { - diff = n1[i] ^ n2[i]; - - if (diff == 0) { - continue; - } - - if (diff == DIFF_NUM && - ((n1[i] >= 'a' && n1[i] <= 'z') || - (n1[i] >= 'A' && n1[i] <= 'Z'))) { - continue; - } - return -1; + if (tag == MBEDTLS_ASN1_UTF8_STRING || tag == MBEDTLS_ASN1_PRINTABLE_STRING) { + return true; } - - return 0; + return false; } -static int X509_StringCmp(const mbedtls_x509_buf *a, const mbedtls_x509_buf *b) +static int32_t CompareX509String(const mbedtls_x509_buf *first, const mbedtls_x509_buf *second) { - if (a->tag == b->tag && - a->len == b->len && - memcmp(a->p, b->p, b->len) == 0) { - return 0; - } - - if ((a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING) && - (b->tag == MBEDTLS_ASN1_UTF8_STRING || b->tag == MBEDTLS_ASN1_PRINTABLE_STRING) && - a->len == b->len && - X509_MemcaseCmp(a->p, b->p, b->len) == 0) { + if (IsLegitString(first->tag) && IsLegitString(second->tag)) { + for (int32_t i = 0; i < first->len; i++) { + if (first->p[i] == second->p[i] || + ((islower(first->p[i]) != 0) && (first->p[i] - DIFF_NUM == second->p[i])) || + ((isupper(first->p[i]) != 0) && (first->p[i] + DIFF_NUM == second->p[i]))) { + continue; + } + return -1; + } return 0; } - return -1; } -static int X509_NameCmp(const mbedtls_x509_name *a, const mbedtls_x509_name *b) +static int32_t GetDeps(const mbedtls_x509_name *nameList) { - /* Avoid recursion, it might not be optimised by the compiler */ - while (a != NULL || b != NULL) { - if (a == NULL || b == NULL) { - return -1; - } - - /* type */ - if (a->oid.tag != b->oid.tag || - a->oid.len != b->oid.len || - memcmp(a->oid.p, b->oid.p, b->oid.len) != 0) { - return -1; - } - - /* value */ - if (X509_StringCmp(&a->val, &b->val) != 0) { - return -1; - } - - /* structure of the list of sets */ - if (a->next_merged != b->next_merged) { - return -1; - } - - a = a->next; - b = b->next; + int32_t deps = 0; + while (nameList != NULL) { + nameList = nameList->next; + deps++; } - - return 0; + return deps; } -static void *Pkcs7Calloc(size_t nmemb, size_t size) +static int32_t CompareX509NameList(const mbedtls_x509_name *first, const mbedtls_x509_name *second) { -#if (RUNNING_BOARD == LITE_WEARABLE) - void *ptr = PSRAM_Malloc(nmemb * size); - if (ptr == NULL) { - return NULL; + if (first == NULL || second == NULL) { + return -1; } - (void)memset_s(ptr, nmemb * size, 0, nmemb * size); - return ptr; -#else - return calloc(nmemb, size); -#endif + int32_t firstDeps = GetDeps(first); + int32_t secondDeps = GetDeps(second); + if (firstDeps != secondDeps) { + return -1; + } + for (int32_t i = 0; i < firstDeps; i++) { + if (first->oid.tag != second->oid.tag || + first->oid.len != second->oid.len || + memcmp(first->oid.p, second->oid.p, second->oid.len) != 0 || + first->MBEDTLS_PRIVATE(next_merged) != second->MBEDTLS_PRIVATE(next_merged) || + first->val.len != second->val.len) { + return -1; + } + if (CompareX509String(&first->val, &second->val) != 0) { + return -1; + } + first = first->next; + second = second->next; + } + return 0; } -static void Pkcs7Free(void *ptr) -{ -#if (RUNNING_BOARD == LITE_WEARABLE) - PSRAM_Free(ptr); -#else - free(ptr); -#endif -} -/* - * SET OF SignerInfo - * SignerInfo ::= SEQUENCE { - * version Version, - * issuerAndSerialNumber IssuerAndSerialNumber, - * digestAlgorithm DigestAlgorithmIdentifier, - * authenticatedAttributes [0] IMPLICIT Attributes OPTIONAL, - * digestEncryptionAlgorithm DigestEncryptionAlgorithmIdentifier, - * encryptedDigest EncryptedDigest, - * unauthenticatedAttributes [1] IMPLICIT Attributes OPTIONAL, - */ -static int ParseSignedDataSignerInfos(unsigned char **p, const unsigned char *end, SignerInfo *signers) +static int32_t ParseSignedDataSignerInfos(unsigned char **p, const unsigned char *end, SignerInfo *signers) { - int rc; - size_t len; + int32_t rc; + size_t len = 0; rc = mbedtls_asn1_get_tag(p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SET); if (rc || len == 0) { @@ -523,39 +1312,28 @@ static int ParseSignedDataSignerInfos(unsigned char **p, const unsigned char *en signers = signers->next; } } - -OUT: return rc; } -static int ParseSignedDataVersion(unsigned char **p, const unsigned char *end, int *ver) +static int32_t ParseSignedDataVersion(unsigned char **p, const unsigned char *end, int32_t *ver) { - int rc = mbedtls_asn1_get_int(p, end, ver); + int32_t rc = mbedtls_asn1_get_int(p, end, ver); if (rc) { return rc; } if (*ver != PKCS7_SIGNED_DATA_VERSION) { - HILOG_ERROR(LOG_MODULE_AAFWK, "Invalid version : %d", *ver); + HILOG_ERROR(HILOG_MODULE_AAFWK, "Invalid version : %d\n", *ver); return PKCS7_INVALID_VERSION; } - HILOG_INFO(LOG_MODULE_AAFWK, "Parse signed data version success"); + HILOG_INFO(HILOG_MODULE_AAFWK, "Parse signed data version success\n"); return PKCS7_SUCC; } -/* - * digestAlgorithms DigestAlgorithmIdentifiers - * DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier - * DigestAlgorithmIdentifier ::= AlgorithmIdentifier - * AlgorithmIdentifier ::= SEQUENCE { -- defined in X509 - * algorithm OBJECT IDENTIFIER, - * parameters ANY DEFINED BY algorithm OPTIONAL } - * } - */ -static int ParseSignedDataDigestAlgs(unsigned char **p, const unsigned char *end, DigestAlgId *algIds) +static int32_t ParseSignedDataDigestAlgs(unsigned char **p, const unsigned char *end, DigestAlgId *algIds) { - int rc; - size_t len; + int32_t rc; + size_t len = 0; /* parse SET OF header */ rc = mbedtls_asn1_get_tag(p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SET); @@ -566,9 +1344,8 @@ static int ParseSignedDataDigestAlgs(unsigned char **p, const unsigned char *end /* parse SET OF 's digest alg content */ DigestAlgId *id = algIds; - id->next = NULL; while (*p < end) { - mbedtls_asn1_buf params; + mbedtls_asn1_buf params = {0}; /* alg param is supported, but not be used now */ rc = mbedtls_asn1_get_alg(p, end, &id->algBuf, ¶ms); if (rc) { @@ -589,42 +1366,36 @@ static int ParseSignedDataDigestAlgs(unsigned char **p, const unsigned char *end return PKCS7_SUCC; } -/* - * parse signedData's content info, what content is defined by user. - * it maybe store the original data be signed, or the calculated hash of original data. - * here just get the content data, do not resolved the detail info. - * - * ContentInfo ::= SEQUENCE { - * contentType ContentType, - * content [0] EXPLICIT ANY DEFINED BY contentType OPTIONAL } - */ -static int ParseSignedDataContentInfo(unsigned char **p, const unsigned char *end, Content *content) +static void DlogContentInfo(const Content *content) { - int rc; - size_t len; + int32_t len = content->data.len; + if (len <= 0) { + return; + } + char *info = Pkcs7Calloc(len + 1, sizeof(char)); + if (info == NULL) { + return; + } + if (strncpy_s(info, len + 1, (char *)content->data.p, len) != EOK) { + Pkcs7Free(info); + return; + } + Pkcs7Free(info); +} + +static int32_t ParseSignedDataContentInfo(unsigned char **p, const unsigned char *end, Content *content) +{ + int32_t rc; + size_t len = 0; bool hasContent = false; rc = GetContentInfoType(p, end, &content->oid, &hasContent); if (rc) { return rc; } - /* - * for our use case, the optional content must has real content info. - * - * rfc2315(PKCS#7) 9.1 shows this: - * contentInfo is the content that is signed. It can have __any__ of the defined content types - * rfc2315(PKCS#7) 9.2 shows this: - * authenticatedAttributes is a set of attributes that are signed (i.e., authenticated) by the signer. - * The field is optional, but it must be present if the content type of the ContentInfo value being - * signed __is not data__. - * So the oid is allowed to be non-MBEDTLS_OID_PKCS7_DATA type? if so, delete below oid type check. - * It defined six content types:data, signedData, envelopedData, signedAndEnvelopedData, digestedData, - * and encryptedData. - * As current content info is in signedData, so i think it can not be other content type other than data. - * It is MBEDTLS_OID_PKCS7_DATA for all of pkcs7-signed-data packages signed by signning tools now. - */ - if (MBEDTLS_OID_CMP(MBEDTLS_OID_PKCS7_DATA, &content->oid) || hasContent == false) { - HILOG_ERROR(LOG_MODULE_AAFWK, "Invalid content type or has no real content"); + + if (MBEDTLS_OID_CMP(MBEDTLS_OID_PKCS7_DATA, &content->oid) || !hasContent) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Invalid content type or has no real content"); return PKCS7_INVALID_CONTENT_TYPE_OR_NO_CONTENT; } rc = GetContentLenOfContentInfo(p, end, &len); @@ -634,29 +1405,19 @@ static int ParseSignedDataContentInfo(unsigned char **p, const unsigned char *en content->data.tag = MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC; // has no use content->data.p = *p; content->data.len = len; + DlogContentInfo(content); *p += len; - return rc; + return PKCS7_SUCC; } -/* - * certificates [0] IMPLICIT ExtendedCertificatesAndCertificates OPTIONAL, - * ExtendedCertificatesAndCertificates ::= SET OF ExtendedCertificateOrCertificate - * ExtendedCertificateOrCertificate ::= CHOICE { - * certificate Certificate, -- X.509 - * extendedCertificate [0] IMPLICIT ExtendedCertificate } - * Certificate ::= SEQUENCE { - * tbsCertificate TBSCertificate, - * signatureAlgorithm AlgorithmIdentifier, - * signatureValue BIT STRING } - */ -static int ParseSignedDataCerts(unsigned char **p, const unsigned char *end, mbedtls_x509_crt **certs) +static int32_t ParseSignedDataCerts(unsigned char **p, const unsigned char *end, mbedtls_x509_crt **certs) { - int rc; - size_t len; + int32_t rc; + size_t len = 0; rc = mbedtls_asn1_get_tag(p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC); if (rc) { - HILOG_ERROR(LOG_MODULE_AAFWK, "Has no certificates in signed data."); + HILOG_ERROR(HILOG_MODULE_AAFWK, "Has no certificates in signed data."); return PKCS7_SUCC; } *certs = mbedtls_calloc(1, sizeof(**certs)); @@ -666,70 +1427,205 @@ static int ParseSignedDataCerts(unsigned char **p, const unsigned char *end, mbe mbedtls_x509_crt_init(*certs); unsigned char *certsEnd = *p + len; - int cnt = 0; + int32_t cnt = 0; while (*p < certsEnd) { /* scan every cert */ size_t oneCertLen; unsigned char *seqBegin = *p; rc = mbedtls_asn1_get_tag(p, end, &oneCertLen, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE); if (rc) { + mbedtls_free(*certs); + *certs = NULL; return rc; } if (oneCertLen + (*p - seqBegin) > (certsEnd - seqBegin)) { + mbedtls_free(*certs); + *certs = NULL; return PKCS7_PARSING_ERROR; } rc = mbedtls_x509_crt_parse(*certs, seqBegin, oneCertLen + (*p - seqBegin)); if (rc) { + mbedtls_free(*certs); + *certs = NULL; return rc; } *p += oneCertLen; cnt++; } - HILOG_INFO(LOG_MODULE_AAFWK, "Parse signed data certs success"); + HILOG_INFO(HILOG_MODULE_AAFWK, "Parse signed data certs success"); return rc; } -/* - * crls [1] IMPLICIT CertificateRevocationLists OPTIONAL, - * CertificateRevocationLists ::= SET OF CertificateRevocationList - * defined in RFC 1422 - * CertificateRevocationList ::= SIGNED SEQUENCE { - * signature AlgorithmIdentifier, - * issuer Name, - * lastUpdate UTCTime, - * nextUpdate UTCTime, - * revokedCertificates SEQUENCE OF CRLEntry OPTIONAL} - */ -static int ParseSignedDataCrl(unsigned char **p, const unsigned char *end, mbedtls_x509_crl *crl) +static int32_t ParseSignedDataCrl(unsigned char **p, const unsigned char *end, mbedtls_x509_crl *crl) { - int rc; - size_t len; + int32_t rc; + size_t len = 0; rc = mbedtls_asn1_get_tag(p, end, &len, (MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_CONTEXT_SPECIFIC) + 1); if (rc) { - HILOG_INFO(LOG_MODULE_AAFWK, "Has no crl in signed data."); + HILOG_INFO(HILOG_MODULE_AAFWK, "Has no crl in signed data."); return PKCS7_SUCC; } - (void)crl; + mbedtls_x509_crl_init(crl); + rc = mbedtls_x509_crl_parse(crl, *p, len); *p += len; return rc; } -/* - * SignedData ::= SEQUENCE { - * version Version, - * digestAlgorithms DigestAlgorithmIdentifiers, - * contentInfo ContentInfo, - * certificates [0] IMPLICIT ExtendedCertificatesAndCertificates OPTIONAL, - * crls [1] IMPLICIT CertificateRevocationLists OPTIONAL, - * signerInfos SignerInfos } - */ -static int ParseSignedData(unsigned char *buf, size_t bufLen, SignedData *signedData) +static mbedtls_x509_crt *FindSuperCert(mbedtls_x509_crt *cur, mbedtls_x509_crt *certsList) +{ + /* current level's subject is next level issuer */ + while (certsList != NULL) { + if (CompareX509NameList(&cur->issuer, &certsList->subject) == 0) { + break; + } + certsList = certsList->next; + } + return certsList; +} + +static int32_t LoadSelfSignedCert(void) +{ + mbedtls_x509_crt_init(&g_ohosRootCert); + int32_t rc = mbedtls_x509_crt_parse(&g_ohosRootCert, OHOS_ROOT_CERT_IN_PEM, sizeof(OHOS_ROOT_CERT_IN_PEM)); + if (rc) { + HILOG_ERROR(HILOG_MODULE_AAFWK,"load oh signed ca failed %d", rc); + return rc; + } else { + HILOG_INFO(HILOG_MODULE_AAFWK,"load oh signed root ca success"); + } + return rc; +} + +static int32_t FindAndStoreRootCert(mbedtls_x509_crt *topCert) +{ + int32_t rc = PKCS7_PARSING_ERROR; + DIR *dir = NULL; + struct dirent *entry = NULL; + char certPath[MAX_CERTPATH_LEN]; + if (access(OEM_CERT_PATH, F_OK) != 0) { + HILOG_DEBUG(HILOG_MODULE_AAFWK, "Please upload the application root certificate."); + return LoadSelfSignedCert(); + } + dir = opendir(OEM_CERT_PATH); + if (dir == NULL) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Failed to open certificate directory."); + return PKCS7_BUILD_CERT_PATH_FAIL; + } + while ((entry = readdir(dir)) != NULL) { + const char *ext = strrchr(entry->d_name, '.'); + if (ext == NULL || strcmp(ext, ".pem") != 0) { + continue; + } + rc = snprintf_s(certPath, sizeof(certPath), sizeof(certPath) - 1, OEM_CERT_PATH"%s", entry->d_name); + if (rc < 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Get cert path failed, return %d!", rc); + continue; + } + mbedtls_x509_crt tmpRootCert; + mbedtls_x509_crt_init(&tmpRootCert); + rc = mbedtls_x509_crt_parse_file(&tmpRootCert, certPath); + if (rc != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Parse %s failed: %d.", certPath, rc); + mbedtls_x509_crt_free(&tmpRootCert); + continue; + } + /* Compare the subject of the device root certificate and the issuer of the uppermost certificate. */ + if (CompareX509NameList(&tmpRootCert.subject, &topCert->issuer) == 0) { + HILOG_INFO(HILOG_MODULE_AAFWK, "Found matching root cert: %s.", entry->d_name); + /* Reparse the root certificate to g_ohosRootCert. */ + rc = mbedtls_x509_crt_parse_file(&g_ohosRootCert, certPath); + if (rc != 0) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "Re-parsing root cert failed: %d!", rc); + mbedtls_x509_crt_free(&tmpRootCert); + closedir(dir); + return PKCS7_HAS_NO_SIGNER_CRT; + } + rc = PKCS7_SUCC; + mbedtls_x509_crt_free(&tmpRootCert); + break; + } + mbedtls_x509_crt_free(&tmpRootCert); + } + + closedir(dir); + return rc; +} + +static int32_t LoadRootCert() +{ + int32_t rc = 0; + if (!g_rootCertLoaded) { + mbedtls_x509_crt_init(&g_rootCaG2Cert); + rc = mbedtls_x509_crt_parse(&g_rootCaG2Cert, g_rootCaG2CertInPem, sizeof(g_rootCaG2CertInPem)); + if (rc) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "load root ca failed!"); + return rc; + } else { + HILOG_INFO(HILOG_MODULE_AAFWK, "load root ca success."); + } + g_rootCertLoaded = true; + } + return rc; +} + +static void UnLoadRootCert(void) +{ + if (g_rootCertLoaded) { + mbedtls_x509_crt_free(&g_rootCaG2Cert); + g_rootCertLoaded = false; + } +} + +static int32_t LoadDebugModeRootCert(void) +{ + mbedtls_x509_crt_init(&g_debugModeRootCert); + int32_t rc = mbedtls_x509_crt_parse(&g_debugModeRootCert, g_debugModeRootCertInPem, + sizeof(g_debugModeRootCertInPem)); + if (rc) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "load debug mode root ca failed %d", rc); + return rc; + } else { + HILOG_INFO(HILOG_MODULE_AAFWK, "load debug mode root ca success"); + } + return rc; +} + +static int32_t UnLoadDebugModeRootCert(void) +{ + mbedtls_x509_crt_free(&g_debugModeRootCert); + return PKCS7_SUCC; +} + +static void UnLoadSelfSignedCert(void) +{ + mbedtls_x509_crt_free(&g_ohosRootCert); +} + +static mbedtls_x509_crt *GetLowLevelCerts(SignedData *signedData) +{ + SignerInfo *signer = &signedData->signers; + mbedtls_x509_buf *signerSerial = &signer->serial; + mbedtls_x509_name *signerIssuer = &signer->issuer; + mbedtls_x509_crt *cert = signedData->certs; + HILOG_INFO(HILOG_MODULE_AAFWK, "To filter one signer's cert"); + while (cert != NULL) { + if (SerialCmp(signerSerial, &cert->serial) == 0 && + CompareX509NameList(signerIssuer, &cert->issuer) == 0) { + HILOG_INFO(HILOG_MODULE_AAFWK, "Found signer's low level cert"); + return cert; + } + cert = cert->next; + } + return NULL; +} + +static int32_t ParseSignedData(unsigned char *buf, size_t bufLen, SignedData *signedData) { unsigned char *p = buf; unsigned char *end = buf + bufLen; size_t len = 0; - size_t rc; + int32_t rc; /* parse SignedData sequence header */ rc = mbedtls_asn1_get_tag(&p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE); @@ -772,6 +1668,7 @@ static int ParseSignedData(unsigned char *buf, size_t bufLen, SignedData *signed /* parse signerInfos */ rc = ParseSignedDataSignerInfos(&p, end, &signedData->signers); + HILOG_INFO(HILOG_MODULE_AAFWK, "ParseSignedDataSignerInfos %d", rc); return rc; } @@ -843,23 +1740,13 @@ static void FreeSignedDataCerts(Pkcs7 *pkcs7) static void FreeSignedDataCrl(Pkcs7 *pkcs7) { - /* add mbedtls_x509_crl_free(&pkcs7->signedData.crl) if added the crl parse */ - (void)pkcs7; + mbedtls_x509_crl_free(&pkcs7->signedData.crl); return; } -#define CERT_BUF_LEN 1024 -static void DLogCertInfo(const mbedtls_x509_crt *cert) +static int32_t GetCertsNumOfSignedData(const mbedtls_x509_crt *crts) { -#if !(RUNNING_BOARD == LITE_WEARABLE) - char buf[CERT_BUF_LEN]; - mbedtls_x509_crt_info(buf, sizeof(buf) - 1, "", cert); -#endif -} - -static int GetCertsNumOfSignedData(const mbedtls_x509_crt *crts) -{ - int cnt = 0; + int32_t cnt = 0; while (crts != NULL) { crts = crts->next; cnt++; @@ -867,18 +1754,6 @@ static int GetCertsNumOfSignedData(const mbedtls_x509_crt *crts) return cnt; } -static mbedtls_x509_crt *FindSuperCert(mbedtls_x509_crt *cur, mbedtls_x509_crt *certsList) -{ - /* current level's subject is next level issuer */ - while (certsList != NULL) { - if (X509_NameCmp(&cur->issuer, &certsList->subject) == 0) { - break; - } - certsList = certsList->next; - } - return certsList; -} - static void DelCertOfSignedData(SignedData *signedData, mbedtls_x509_crt *crt) { mbedtls_x509_crt *head = signedData->certs; @@ -917,24 +1792,12 @@ static void AddCertToSignerCertPath(SignerInfo *signer, mbedtls_x509_crt *crt) signer->certPath.depth++; } -static bool IsRootCert(mbedtls_x509_crt *crt) -{ - if (X509_NameCmp(&g_rootCaG2Cert.subject, &crt->subject) == 0) { - return true; - } - if (g_debugModeEnabled) { - if (X509_NameCmp(&g_debugModeRootCert.subject, &crt->subject) == 0) { - return true; - } - } - return false; -} -static int BuildSignerCertPath(SignerInfo *signer, mbedtls_x509_crt *lowerCrt, SignedData *signeData) +static int32_t BuildSignerCertPath(SignerInfo *signer, mbedtls_x509_crt *lowerCrt, SignedData *signeData) { - int scanCnt = 0; - int rc = PKCS7_SUCC; - if (g_rootCertLoaded == false) { + int32_t scanCnt = 0; + int32_t rc = PKCS7_SUCC; + if (!g_rootCertLoaded) { return PKCS7_ROOT_CA_NOT_VALID; } signer->rootCert = &g_rootCaG2Cert; @@ -944,18 +1807,21 @@ static int BuildSignerCertPath(SignerInfo *signer, mbedtls_x509_crt *lowerCrt, S * find the next level ca cert */ mbedtls_x509_crt *cur = lowerCrt; mbedtls_x509_crt *next = NULL; - int certsCnt = GetCertsNumOfSignedData(certs); + int32_t certsCnt = GetCertsNumOfSignedData(certs); DelCertOfSignedData(signeData, cur); AddCertToSignerCertPath(signer, cur); while (true) { next = FindSuperCert(cur, signeData->certs); if (next == NULL) { + mbedtls_x509_crt_init(&g_ohosRootCert); + rc = FindAndStoreRootCert(cur); + if (rc == 0) { + HILOG_INFO(HILOG_MODULE_AAFWK, "load self signed root ca success"); + } else { + HILOG_ERROR(HILOG_MODULE_AAFWK, "load self signed ca failed %d", rc); + } break; } else { - if (IsRootCert(next)) { - HILOG_INFO(LOG_MODULE_AAFWK, "root cert pack in signed data"); - break; - } DelCertOfSignedData(signeData, next); AddCertToSignerCertPath(signer, next); } @@ -969,39 +1835,28 @@ static int BuildSignerCertPath(SignerInfo *signer, mbedtls_x509_crt *lowerCrt, S return rc; } -static int ConstructSignerCerts(SignedData *signedData) +static int32_t ConstructSignerCerts(SignedData *signedData) { /* scan all of the signers , and filter the signer's certs by serial and name */ SignerInfo *signer = &signedData->signers; while (signer != NULL) { - mbedtls_x509_buf *signerSerial = &signer->serial; - mbedtls_x509_name *signerIssuer = &signer->issuer; - mbedtls_x509_crt *cert = signedData->certs; - HILOG_INFO(LOG_MODULE_AAFWK, "To filter one signer's cert"); - while (cert != NULL) { - if (SerialCmp(signerSerial, &cert->serial) == 0 && - X509_NameCmp(signerIssuer, &cert->issuer) == 0) { - HILOG_INFO(LOG_MODULE_AAFWK, "Found signer's low level cert"); - DLogCertInfo(cert); - break; - } - cert = cert->next; - } + mbedtls_x509_crt *cert = GetLowLevelCerts(signedData); if (cert == NULL) { - HILOG_ERROR(LOG_MODULE_AAFWK, "Could not found signer's lowest cert"); + HILOG_ERROR(HILOG_MODULE_AAFWK, "Could not found signer's lowest cert"); return PKCS7_INVALID_VALUE; } - int rc = BuildSignerCertPath(signer, cert, signedData); + int32_t rc = BuildSignerCertPath(signer, cert, signedData); if (rc != 0) { return rc; } + signer = signer->next; } return 0; } /* get signer digest alg */ -static int GetSignerDigestAlg(const SignerInfo *signer, mbedtls_md_type_t *algType) +static int32_t GetSignerDigestAlg(const SignerInfo *signer, mbedtls_md_type_t *algType) { const mbedtls_x509_buf *alg = &signer->digestAlgId; if (!MBEDTLS_OID_CMP(MBEDTLS_OID_DIGEST_ALG_SHA256, alg)) { @@ -1020,7 +1875,7 @@ static int GetSignerDigestAlg(const SignerInfo *signer, mbedtls_md_type_t *algTy } /* get signer pubkey of sign from signer cert */ -static int GetSignerPubKeyOfSignature(const SignerInfo *signer, mbedtls_pk_context **pk) +static int32_t GetSignerPubKeyOfSignature(const SignerInfo *signer, mbedtls_pk_context **pk) { /* signer cert_path first cert is the lowest cert. yet is the signature cert */ if (signer == NULL || pk == NULL) { @@ -1033,13 +1888,12 @@ static int GetSignerPubKeyOfSignature(const SignerInfo *signer, mbedtls_pk_conte return PKCS7_INVALID_VALUE; } -int PKCS7_VerifySignerSignature(const Pkcs7 *pkcs7, PKCS7_CalcDigest calcDigest) +int32_t PKCS7_VerifySignerSignature(const Pkcs7 *pkcs7, PKCS7_CalcDigest calcDigest) { - int rc; + int32_t rc; if (pkcs7 == NULL || calcDigest == NULL) { return PKCS7_INVALID_PARAM; } - const SignerInfo *signer = &pkcs7->signedData.signers; unsigned char *sig = NULL; size_t sigLen; @@ -1048,7 +1902,7 @@ int PKCS7_VerifySignerSignature(const Pkcs7 *pkcs7, PKCS7_CalcDigest calcDigest) if (rc) { return rc; } - HILOG_INFO(LOG_MODULE_AAFWK, "get signer signature len : %lu", sigLen); + HILOG_INFO(HILOG_MODULE_AAFWK, "get signer signature len : %zu", sigLen); mbedtls_pk_context *pk = NULL; rc = GetSignerPubKeyOfSignature(signer, &pk); @@ -1060,125 +1914,146 @@ int PKCS7_VerifySignerSignature(const Pkcs7 *pkcs7, PKCS7_CalcDigest calcDigest) if (rc) { return rc; } - unsigned char hash[MAX_HASH_SIZE]; + (void)memset_s(hash, MAX_HASH_SIZE, 0, MAX_HASH_SIZE); size_t hashLen = 0; rc = calcDigest(pkcs7, signer, digAlg, hash, &hashLen); if (rc) { - HILOG_ERROR(LOG_MODULE_AAFWK, "Calculate content hash failed by calling callback"); + HILOG_ERROR(HILOG_MODULE_AAFWK, "Calculate content hash failed by calling callback"); return rc; } /* if is rsassa-pss, need to set padding version to V21, RFC3447 */ if (!MBEDTLS_OID_CMP(MBEDTLS_OID_RSASSA_PSS, &signer->digestEncAlgId)) { - mbedtls_rsa_set_padding(pk->pk_ctx, MBEDTLS_RSA_PKCS_V21, 0); + mbedtls_rsa_set_padding(pk->MBEDTLS_PRIVATE(pk_ctx), MBEDTLS_RSA_PKCS_V21, (mbedtls_md_type_t)0); } rc = mbedtls_pk_verify(pk, digAlg, hash, hashLen, sig, sigLen); + (void)memset_s(hash, MAX_HASH_SIZE, 0, MAX_HASH_SIZE); if (rc) { - HILOG_ERROR(LOG_MODULE_AAFWK, "Verify signature failed, returned -0x%04x", rc); + HILOG_ERROR(HILOG_MODULE_AAFWK, "Verify signature failed, returned -0x%04x", rc); return rc; } else { - HILOG_INFO(LOG_MODULE_AAFWK, "Verify signer signature success"); + HILOG_INFO(HILOG_MODULE_AAFWK, "Verify signer signature success\n"); } - signer = signer->next; } return rc; } -static int LoadRootCert(void) +static void DLogCrtVerifyInfo(uint32_t flags) { - int rc = 0; - if (g_rootCertLoaded == false) { - mbedtls_x509_crt_init(&g_rootCaG2Cert); - rc = mbedtls_x509_crt_parse(&g_rootCaG2Cert, g_rootCaG2CertInPem, sizeof(g_rootCaG2CertInPem)); - if (rc) { - HILOG_ERROR(LOG_MODULE_AAFWK, "load root ca failed"); - return rc; - } else { - HILOG_INFO(LOG_MODULE_AAFWK, "load root ca success"); + char vrfyBuf[VERIFY_BUF_LEN]; + (void)memset_s(vrfyBuf, VERIFY_BUF_LEN, 0, VERIFY_BUF_LEN); + mbedtls_x509_crt_verify_info(vrfyBuf, sizeof(vrfyBuf), " ! ", flags); + HILOG_DEBUG(HILOG_MODULE_AAFWK, "%s", vrfyBuf); +} + +static int32_t IsRevoked(const mbedtls_x509_crt *crt, const mbedtls_x509_crl *crl) +{ + mbedtls_x509_crl_entry *cur = (mbedtls_x509_crl_entry *)(&crl->entry); + while (cur != NULL) { + if (cur->serial.len == 0) { + return PKCS7_SUCC; } - DLogCertInfo(&g_rootCaG2Cert); - g_rootCertLoaded = true; + if (crt->serial.len != cur->serial.len) { + cur = cur->next; + continue; + } + if (memcmp(crt->serial.p, cur->serial.p, cur->serial.len) == 0) { + return PKCS7_IS_REVOKED; + } + cur = cur->next; } - return rc; + return PKCS7_SUCC; } -static void UnLoadRootCert(void) + +static int32_t VerifyCrl(const mbedtls_x509_crt *crt, const mbedtls_x509_crl *crl) { - if (g_rootCertLoaded == true) { - mbedtls_x509_crt_free(&g_rootCaG2Cert); - g_rootCertLoaded = false; + const mbedtls_x509_crl *crlList = crl; + while (crlList != NULL) { + if (crlList->version == 0 || + CompareX509NameList(&crlList->issuer, &crt->issuer) != 0) { + crlList = crlList->next; + continue; + } + HILOG_INFO(HILOG_MODULE_AAFWK, "find crl"); + if (IsRevoked(crt, crlList)) { + return PKCS7_IS_REVOKED; + } + crlList = crlList->next; } + return PKCS7_SUCC; } -static int LoadDebugModeRootCert(void) +static int32_t VerifyClicert(mbedtls_x509_crt *clicert, mbedtls_x509_crt *rootCert, const Pkcs7 *pkcs7) { - int rc; - mbedtls_x509_crt_init(&g_debugModeRootCert); - rc = mbedtls_x509_crt_parse(&g_debugModeRootCert, g_debugModeRootCertInPem, sizeof(g_debugModeRootCertInPem)); + uint32_t flags; + int32_t rc = mbedtls_x509_crt_verify(clicert, rootCert, + (mbedtls_x509_crl *)&pkcs7->signedData.crl, NULL, &flags, NULL, NULL); if (rc) { - HILOG_ERROR(LOG_MODULE_AAFWK, "load debug mode root ca failed"); - return rc; + DLogCrtVerifyInfo(flags); } else { - HILOG_INFO(LOG_MODULE_AAFWK, "load debug mode root ca success"); + HILOG_INFO(HILOG_MODULE_AAFWK, "Verify signers cert chain root cert success"); + if (VerifyCrl(clicert, (mbedtls_x509_crl *)&pkcs7->signedData.crl) != PKCS7_SUCC) { + HILOG_ERROR(HILOG_MODULE_AAFWK, "cert crl verify failed"); + return PKCS7_IS_REVOKED; + } + return PKCS7_SUCC; } - DLogCertInfo(&g_debugModeRootCert); return rc; } -static int UnLoadDebugModeRootCert(void) -{ - mbedtls_x509_crt_free(&g_debugModeRootCert); - return PKCS7_SUCC; -} -int PKCS7_VerifyCertsChain(const Pkcs7 *pkcs7) +int32_t PKCS7_VerifyCertsChain(const Pkcs7 *pkcs7) { if (pkcs7 == NULL) { return PKCS7_INVALID_PARAM; } - - int cnt = 0; + int32_t cnt = 0; const SignerInfo *signer = &pkcs7->signedData.signers; while (signer != NULL) { mbedtls_x509_crt *clicert = signer->certPath.crt; if (clicert == NULL) { - signer = signer->next; - HILOG_ERROR(LOG_MODULE_AAFWK, "Signer has no certs"); + HILOG_ERROR(HILOG_MODULE_AAFWK, "Signer has no certs"); return PKCS7_HAS_NO_SIGNER_CRT; } - unsigned int flags; - int rc; + int32_t rc; cnt++; - HILOG_INFO(LOG_MODULE_AAFWK, "signer : %d", cnt); + HILOG_INFO(HILOG_MODULE_AAFWK, "signer : %d", cnt); if (g_debugModeEnabled) { - rc = mbedtls_x509_crt_verify(clicert, &g_debugModeRootCert, NULL, NULL, &flags, NULL, NULL); - if (rc) { - HILOG_ERROR(LOG_MODULE_AAFWK, - "Verify signer[%d]'s cert failed by debug mode, rc: %d", cnt, rc); - } else { - HILOG_INFO(LOG_MODULE_AAFWK, - "Verify signers cert chain by debug mode root cert success"); + rc = VerifyClicert(clicert, &g_debugModeRootCert, pkcs7); + HILOG_DEBUG(HILOG_MODULE_AAFWK, "Verify inner: %d", rc); + if (rc == PKCS7_SUCC) { signer = signer->next; continue; } + if (rc == PKCS7_IS_REVOKED) { + return PKCS7_IS_REVOKED; + } } - - mbedtls_x509_crt *rootCert = signer->rootCert; - - rc = mbedtls_x509_crt_verify(clicert, rootCert, NULL, NULL, &flags, NULL, NULL); - if (rc) { - HILOG_ERROR(LOG_MODULE_AAFWK, "Verify signer[%d]'s cert failed, rc: %d", cnt, rc); - return rc; - } else { - HILOG_INFO(LOG_MODULE_AAFWK, "Verify signer[%d]'s certs chain success", cnt); + rc = VerifyClicert(clicert, signer->rootCert, pkcs7); + HILOG_DEBUG(HILOG_MODULE_AAFWK, "Verify : %d", rc); + if (rc == PKCS7_SUCC) { + signer = signer->next; + continue; } - signer = signer->next; + if (rc == PKCS7_IS_REVOKED) { + return PKCS7_IS_REVOKED; + } +#ifndef OHOS_SIGN_HAPS_BY_SERVER + rc = VerifyClicert(clicert, &g_ohosRootCert, pkcs7); + HILOG_DEBUG(HILOG_MODULE_AAFWK, "Verify self : %d", rc); + if (rc == PKCS7_SUCC) { + signer = signer->next; + continue; + } +#endif + return rc; } return PKCS7_SUCC; } -int PKCS7_GetSignerSignningCertSubject(const SignerInfo *signer, char *subject, size_t subjectLen) +int32_t PKCS7_GetSignerSignningCertSubject(const SignerInfo *signer, char *subject, size_t subjectLen) { - int rc; + int32_t rc; if (signer == NULL || subject == NULL) { return PKCS7_INVALID_PARAM; } @@ -1190,9 +2065,9 @@ int PKCS7_GetSignerSignningCertSubject(const SignerInfo *signer, char *subject, return PKCS7_SUCC; } -int PKCS7_GetSignerSignningCertIssuer(const SignerInfo *signer, char *issuer, size_t issuerLen) +int32_t PKCS7_GetSignerSignningCertIssuer(const SignerInfo *signer, char *issuer, size_t issuerLen) { - int rc; + int32_t rc; if (signer == NULL || issuer == NULL) { return PKCS7_INVALID_PARAM; } @@ -1213,10 +2088,41 @@ static size_t GetSignersCnt(const SignerInfo *signers) } return cnt; } -static size_t GetSignerSignningCertDepth(const SignerInfo *signer) + +static bool IsIncludeRoot(const SignerInfo *signer) +{ + mbedtls_x509_crt *pre = signer->certPath.crt; + mbedtls_x509_crt *cur = pre; + int32_t i = 0; + while (i < signer->certPath.depth && cur != NULL) { + pre = cur; + cur = cur->next; + i++; + } + + if (pre == NULL) { + return false; + } + + /* root cert is a self-sign cert */ + if (CompareX509NameList(&pre->issuer, &pre->subject) == 0) { + HILOG_INFO(HILOG_MODULE_AAFWK, "Include root cert"); + return true; + } + HILOG_INFO(HILOG_MODULE_AAFWK, "Not include root cert"); + return false; +} + +static int32_t GetSignerSignningCertDepth(const SignerInfo *signer) { - return signer->certPath.depth + 1; // 1 for root cert; + if (IsIncludeRoot(signer)) { + return signer->certPath.depth; + } + + /* root cert is not included in signer->certPath, add 1 for root cert */ + return signer->certPath.depth + 1; } + void PKCS7_FreeAllSignersResolvedInfo(SignersResovedInfo *sri) { if (sri == NULL) { @@ -1249,10 +2155,9 @@ SignersResovedInfo *PKCS7_GetAllSignersResolvedInfo(const Pkcs7 *pkcs7) Pkcs7Free(sri); return NULL; } - int rc; - + int32_t rc; const SignerInfo *signer = &pkcs7->signedData.signers; - int idx = 0; + int32_t idx = 0; while (signer != NULL && idx < signersCnt) { rc = PKCS7_GetSignerSignningCertSubject(signer, sri->signers[idx].subject, sizeof(sri->signers[idx].subject)); if (rc) { @@ -1273,21 +2178,23 @@ OUT: return NULL; } -int PKCS7_GetDigestInSignerAuthAttr(const SignerInfo *signer, unsigned char **dig, size_t *digLen) +int32_t PKCS7_GetDigestInSignerAuthAttr(const SignerInfo *signer, unsigned char **dig, size_t *digLen) { + if (signer == NULL || dig == NULL || digLen == NULL) { + return PKCS7_INVALID_VALUE; + } unsigned char *p = signer->authAttr.p; - unsigned char *end = p + signer->authAttr.len; - size_t tmpLen; - int rc; - if (p == NULL) { return PKCS7_HAS_NO_AUTH_ATTR_IN_SIGNER; } + unsigned char *end = p + signer->authAttr.len; + size_t tmpLen = 0; + /* SET OF SEQUENCE */ while (p < end) { size_t seqLen; unsigned char *seqEnd = NULL; - rc = mbedtls_asn1_get_tag(&p, end, &seqLen, MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED); + int32_t rc = mbedtls_asn1_get_tag(&p, end, &seqLen, MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED); if (rc) { return rc; } @@ -1320,35 +2227,18 @@ int PKCS7_GetDigestInSignerAuthAttr(const SignerInfo *signer, unsigned char **di return PKCS7_INVALID_VALUE; } -int PKCS7_GetSignerAuthAttr(const SignerInfo *signer, unsigned char **data, size_t *dataLen) +int32_t PKCS7_GetSignerAuthAttr(const SignerInfo *signer, unsigned char **data, size_t *dataLen) { - if (signer->authAttrRaw.p == NULL) { + if (signer == NULL || signer->authAttrRaw.p == NULL || data == NULL || dataLen == NULL) { return PKCS7_INVALID_VALUE; } *dataLen = signer->authAttrRaw.len; *data = signer->authAttrRaw.p; - /* - * As PKCS7 explain: - * authenticatedAttributes is a set of attributes that are signed (i.e., - * authenticated) by the signer. The field is optional, but it must be present if the content - * type of the ContentInfo value being signed is not data. If the field is present, - * it must contain, at a minimum, two attributes: - * A PKCS#9 content-type attribute - * A PKCS#9 message-digest attribute - * - * For clarity: The IMPLICIT [0] tag in the authenticatedAttributes field is not part of the Attributes - * value. The Attributes value's tag is SET OF, and the DER encoding of the SET OF tag, - * rather than of the IMPLICIT' [0] tag, is to be digested along with the length and contents - * octets of the Attributes value - * - * So, the tag is SET OF(0x31) when signing, but it will changed to CONTEXT_SPECIFIC(0xa0) when packing to - * signer's structure. so we must change it to original SET OF(0x31) for calculate digest. - */ *(unsigned char *)signer->authAttrRaw.p = MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SET; return PKCS7_SUCC; } -int PKCS7_GetContentData(const Pkcs7 *pkcs7, unsigned char **data, size_t *dataLen) +int32_t PKCS7_GetContentData(const Pkcs7 *pkcs7, unsigned char **data, size_t *dataLen) { if (pkcs7 == NULL || data == NULL || dataLen == NULL) { return PKCS7_INVALID_PARAM; @@ -1358,7 +2248,7 @@ int PKCS7_GetContentData(const Pkcs7 *pkcs7, unsigned char **data, size_t *dataL size_t len = pkcs7->signedData.content.data.len; unsigned char *end = p + len; size_t octetLen; - int rc = mbedtls_asn1_get_tag(&p, end, &octetLen, MBEDTLS_ASN1_OCTET_STRING); + int32_t rc = mbedtls_asn1_get_tag(&p, end, &octetLen, MBEDTLS_ASN1_OCTET_STRING); if (rc != 0) { return rc; } @@ -1367,28 +2257,29 @@ int PKCS7_GetContentData(const Pkcs7 *pkcs7, unsigned char **data, size_t *dataL return PKCS7_SUCC; } -int PKCS7_EnableDebugMode(bool mode) +int32_t PKCS7_EnableDebugMode(bool mode) { if (g_debugModeEnabled == mode) { return PKCS7_SUCC; } - int rc = ((mode == true) ? LoadDebugModeRootCert() : UnLoadDebugModeRootCert()); + int32_t rc = ((mode == true) ? LoadDebugModeRootCert() : UnLoadDebugModeRootCert()); if (rc) { return rc; } g_debugModeEnabled = mode; - return rc; + return PKCS7_SUCC; } + #ifdef PARSE_PEM_FORMAT_SIGNED_DATA -static int ParsePemFormatSignedData(const unsigned char *buf, size_t bufLen, mbedtls_pem_context *pem, char *format) +static int32_t ParsePemFormatSignedData(const unsigned char *buf, size_t bufLen, mbedtls_pem_context *pem, char *format) { if (bufLen != 0 && strstr((const char *)buf, "-----BEGIN PKCS7-----") != NULL) { - int ret; - size_t useLen; + int32_t rc; + size_t useLen = 0; mbedtls_pem_init(pem); - ret = mbedtls_pem_read_buffer(pem, "-----BEGIN PKCS7-----", "-----END PKCS7-----", + rc = mbedtls_pem_read_buffer(pem, "-----BEGIN PKCS7-----", "-----END PKCS7-----", buf, NULL, 0, &useLen); - if (ret == 0 && useLen == bufLen) { + if (rc == 0 && useLen == bufLen) { *format = PEM_FORMAT_SINGED_DATA; return PKCS7_SUCC; } @@ -1400,10 +2291,11 @@ static int ParsePemFormatSignedData(const unsigned char *buf, size_t bufLen, mbe return PKCS7_INVALID_PARAM; } #endif -int PKCS7_ParseSignedData(const unsigned char *buf, size_t bufLen, Pkcs7 *pkcs7) + +int32_t PKCS7_ParseSignedData(const unsigned char *buf, size_t bufLen, Pkcs7 *pkcs7) { - int rc; - size_t len; + int32_t rc; + size_t len = 0; bool hasContent = false; unsigned char *start = NULL; unsigned char *end = NULL; @@ -1413,56 +2305,63 @@ int PKCS7_ParseSignedData(const unsigned char *buf, size_t bufLen, Pkcs7 *pkcs7) (void)memset_s(pkcs7, sizeof(*pkcs7), 0, sizeof(*pkcs7)); start = (unsigned char *)buf; #ifdef PARSE_PEM_FORMAT_SIGNED_DATA - char format; + char format = 0; rc = ParsePemFormatSignedData(buf, bufLen, &pkcs7->pem, &format); if (rc) { - goto OUT; + goto EXIT; } if (format == PEM_FORMAT_SINGED_DATA) { - start = pkcs7->pem.buf; - bufLen = pkcs7->pem.buflen; + start = pkcs7->pem.MBEDTLS_PRIVATE(buf); + bufLen = pkcs7->pem.MBEDTLS_PRIVATE(buflen); } #endif - end = start + bufLen; - - /* loaded the root ca cert */ +#ifdef MARKET_ENABLE + if (access(OEM_CERT_PATH, F_OK) == 0) { + rc = VerifyHashList(); + P_ERR_GOTO_WTTH_LOG(rc); + } +#endif + /* loaded the c2 root ca cert */ rc = LoadRootCert(); - PKCS7_ERR_GOTO_OUT(rc); - HILOG_INFO(LOG_MODULE_AAFWK, "Begin to parse pkcs#7 signed data", 0); + P_ERR_GOTO_WTTH_LOG(rc); + HILOG_INFO(HILOG_MODULE_AAFWK, "Begin to parse pkcs#7 signed data"); + end = start + bufLen; /* parse the ContentInfo total head */ rc = GetContentInfoType(&start, end, &(pkcs7->contentTypeOid), &hasContent); - PKCS7_ERR_GOTO_OUT(rc); - - if (!IsSigedDataOid(pkcs7) || hasContent == false) { + P_ERR_GOTO_WTTH_LOG(rc); + if (!IsSigedDataOid(pkcs7) || !hasContent) { rc = PKCS7_INVALID_CONTENT_TYPE_OR_NO_CONTENT; - HILOG_ERROR(LOG_MODULE_AAFWK, - "Input data is not pkcs#7 signed data format or has no content info"); - goto OUT; + HILOG_ERROR(HILOG_MODULE_AAFWK, "Input data is not pkcs#7 signed data format or has no content info"); + goto EXIT; } rc = GetContentLenOfContentInfo(&start, end, &len); - PKCS7_ERR_GOTO_OUT(rc); + P_ERR_GOTO_WTTH_LOG(rc); if (start + len > end) { - goto OUT; + rc = PKCS7_INVALID_CONTENT_TYPE_OR_NO_CONTENT; + HILOG_ERROR(HILOG_MODULE_AAFWK, "The length of input data is invalid"); + goto EXIT; } rc = ParseSignedData(start, len, &(pkcs7->signedData)); - PKCS7_ERR_GOTO_OUT(rc); - - HILOG_INFO(LOG_MODULE_AAFWK, "Parse pkcs#7 signed data success"); - + P_ERR_GOTO_WTTH_LOG(rc); + HILOG_INFO(HILOG_MODULE_AAFWK, "Parse pkcs#7 signed data success"); rc = ConstructSignerCerts(&pkcs7->signedData); - PKCS7_ERR_GOTO_OUT(rc); + P_ERR_GOTO_WTTH_LOG(rc); return rc; -OUT: - PKCS7_FreeRes(pkcs7); +EXIT: return rc; } void PKCS7_FreeRes(Pkcs7 *pkcs7) { + if (pkcs7 == NULL) { + return; + } FreeSignedDataDigestAlgs(pkcs7); FreeSignersInfo(pkcs7); FreeSignedDataCerts(pkcs7); FreeSignedDataCrl(pkcs7); UnLoadRootCert(); - return; -} +#ifndef OHOS_SIGN_HAPS_BY_SERVER + UnLoadSelfSignedCert(); +#endif +} \ No newline at end of file diff --git a/code/sdk/open_source/openharmony/base/security/appverify/app_verify.c b/code/sdk/open_source/openharmony/base/security/appverify/app_verify.c index cf26c485c..fbe0456f6 100644 --- a/code/sdk/open_source/openharmony/base/security/appverify/app_verify.c +++ b/code/sdk/open_source/openharmony/base/security/appverify/app_verify.c @@ -359,11 +359,12 @@ static void SendSectionMessage(int readLen, int stepPersent, int *countedLen, in static int CacalRootHashByBlockHash(const FileRead *fileRead, int uintLen, int alg, unsigned char *outbuf) { int ret, readLen, rawBufLen, stepPersent; - unsigned char *blockHash = NULL; + unsigned char *totalBlocks = NULL; + size_t totalBlocksSize = 0; + size_t blockOffset = 0; size_t hlen; int countedLen = 0; int num = 0; - const mbedtls_md_info_t *mdInfo = mbedtls_md_info_from_type((mbedtls_md_type_t)alg); P_NULL_RETURN_WTTH_LOG(mdInfo); @@ -384,11 +385,9 @@ static int CacalRootHashByBlockHash(const FileRead *fileRead, int uintLen, int a hlen = mbedtls_md_get_size(mdInfo); - blockHash = APPV_MALLOC(hlen); - P_NULL_GOTO_WTTH_LOG(blockHash); - - ret = mbedtls_md_starts(md_ctx); - P_ERR_GOTO_WTTH_LOG(ret); + size_t expectedBlocks = (fileRead->len + uintLen - 1) / uintLen; + totalBlocks = APPV_MALLOC(expectedBlocks * hlen); + P_NULL_GOTO_WTTH_LOG(totalBlocks); rawBufLen = fileRead->len; lseek(fileRead->fp, fileRead->offset, SEEK_SET); @@ -402,22 +401,34 @@ static int CacalRootHashByBlockHash(const FileRead *fileRead, int uintLen, int a goto EXIT; } /* cacal hash */ - ret = CalculateHash(buf, len, alg, blockHash); + ret = CalculateHash(buf, len, alg, totalBlocks + blockOffset); P_ERR_GOTO_WTTH_LOG(ret); - ret = mbedtls_md_update(md_ctx, blockHash, hlen); - P_ERR_GOTO_WTTH_LOG(ret); + blockOffset += hlen; rawBufLen -= readLen; SendSectionMessage(readLen, stepPersent, &countedLen, &num); } - ret = mbedtls_md_finish(md_ctx, outbuf); + + ret = mbedtls_md_starts(md_ctx); + P_ERR_GOTO_WTTH_LOG(ret); + + size_t processed = 0; + while (processed < blockOffset) { + size_t chunk_size = (blockOffset - processed) > (size_t)uintLen + ? (size_t)uintLen : (blockOffset - processed); + ret = mbedtls_md_update(md_ctx, totalBlocks + processed, chunk_size); + P_ERR_GOTO_WTTH_LOG(ret); + processed += chunk_size; + } + ret = mbedtls_md_finish(md_ctx, outbuf); EXIT: APPV_FREE(buf); - APPV_FREE(blockHash); + APPV_FREE(totalBlocks); mbedtls_md_free(md_ctx); APPV_FREE(md_ctx); return ret; } + static int GetRootHashByBlock(const FileRead *fileRead, int uintLen, int alg, unsigned char **output, int *hashLen) { /* block num */ @@ -1604,4 +1615,4 @@ int APPVERI_GetUnsignedFileLength(const char *filePath) close(handle); APPV_FREE(signHead); return unsignedFileLength; -} +} \ No newline at end of file diff --git a/code/sdk/open_source/openharmony/base/security/appverify/include/app_common.h b/code/sdk/open_source/openharmony/base/security/appverify/include/app_common.h index 410538384..c13877b58 100644 --- a/code/sdk/open_source/openharmony/base/security/appverify/include/app_common.h +++ b/code/sdk/open_source/openharmony/base/security/appverify/include/app_common.h @@ -33,6 +33,7 @@ extern "C" { #define DOUBLE_SIZE 2 #define MAX_CHARACTER 9 #define BYTE_BITS 8 +#define MAX_HASH_SIZE 64 #define FILE_CERCHAIN_VERIFY 10 #define FILE_INTEGRITY_VERIFY 48 diff --git a/code/sdk/open_source/openharmony/base/security/appverify/include/app_verify_pub.h b/code/sdk/open_source/openharmony/base/security/appverify/include/app_verify_pub.h index 5b6d56438..5ad48efa3 100644 --- a/code/sdk/open_source/openharmony/base/security/appverify/include/app_verify_pub.h +++ b/code/sdk/open_source/openharmony/base/security/appverify/include/app_verify_pub.h @@ -18,6 +18,9 @@ #include #include +#include +#include +#include #ifdef __cplusplus #if __cplusplus @@ -115,6 +118,38 @@ typedef struct { int len; } AppSignPk; +#ifdef MARKET_ENABLE +#define NOISE_SIZE 32 +#define SALT_INFO_POOL_ROWS 3 +#define PUBLIC_KEY_FILE_LEN (SALT_INFO_POOL_ROWS * NOISE_SIZE * 2 + 4 + 1) +#define CLIENT_NOISE_LEN (PUBLIC_KEY_FILE_LEN - 4) +#define FRONT_FIXED_SIZE 204 +#define FIXED_BYTES_LEN 6 +#define AES_KEY_LEN 16 +#define ECP_PUBKEY_LEN 65 +#define ENC_TYPE_ECC 0x22 +static const unsigned char FIXED_BYTES[FIXED_BYTES_LEN] = {0xa5, 0x01, 0x02, 0x03, 0x04, 0x5a}; + +#pragma pack(push, 4) +typedef struct { + uint32_t originalLen; + uint32_t encryptedLen; + uint32_t sigLen; + uint32_t sigOffset; + uint32_t appCertLen; + uint32_t intermediateCertLen; + uint8_t iv1[AES_KEY_LEN]; + uint8_t iv2[AES_KEY_LEN]; + uint8_t password[AES_KEY_LEN]; + uint8_t pubKeyType; + uint8_t padLen; + uint8_t padData[AES_KEY_LEN]; + uint8_t dialViewCount; + uint8_t reserve[5]; +} MetadataStruct; +#pragma pack(pop) +#endif + struct VfyRst; typedef int (*GetSignPk)(struct VfyRst *verifyRst, AppSignPk *pk); typedef void (*FreeSignPK)(AppSignPk *pk); @@ -139,10 +174,33 @@ int APPVERI_SetDebugMode(bool mode); /* get unsigned file len without verify, return V_ERR if not OK */ int APPVERI_GetUnsignedFileLength(const char *filePath); +#ifdef MARKET_ENABLE +/******************************************************************************* + * Function : PKCS7_GenerateECCKeypair + * Description : Generate ECC brainpool256R1 key pair and write to PEM files + * + * Return : int 0 on success, non-zero error code on failure + *******************************************************************************/ +int32_t PKCS7_GenerateECCKeypair(); + +/******************************************************************************* + * Function : PKCS7_VerifyAndDecrypt + * Description : Decrypt the signature verification fee dial data and return the + dial data that has passed integrity verification and decryption + * Input : fp - Buffer for storing decrypted dial data + * firstLoad - Is this the first time loading this dial + * meta - Encrypt the metadata data structure content in the dial + * restoredBufLen - The length of decrypted dials header and types + * Output : restoredBuf - Data buffer for storing decrypted dials header and types + * Return : 0 on success, others on fail + *******************************************************************************/ +int32_t PKCS7_VerifyAndDecrypt(FILE *fp, bool firstLoad, MetadataStruct *meta, unsigned char *restoredBuf, uint32_t restoredBufLen); +#endif + #ifdef __cplusplus #if __cplusplus } #endif #endif -#endif +#endif \ No newline at end of file diff --git a/code/sdk/open_source/openharmony/base/security/appverify/include/mbedtls_pkcs7.h b/code/sdk/open_source/openharmony/base/security/appverify/include/mbedtls_pkcs7.h index d55e013d5..a21759a00 100644 --- a/code/sdk/open_source/openharmony/base/security/appverify/include/mbedtls_pkcs7.h +++ b/code/sdk/open_source/openharmony/base/security/appverify/include/mbedtls_pkcs7.h @@ -16,6 +16,7 @@ #ifndef MBEDTLS_PKCS7_H #define MBEDTLS_PKCS7_H #include +#include #include #include #include @@ -56,6 +57,12 @@ typedef enum { PKCS7_HAS_NO_AUTH_ATTR_IN_SIGNER, PKCS7_HAS_NO_SIGNER_INFO, PKCS7_HAS_NO_SIGNER_CRT, + PKCS7_IS_REVOKED, + PKCS7_VERIFY_FAIL, + PKCS7_SAVE_PUB_KEY_FAIL, + PKCS7_GET_PUB_KEY_FAIL, + PKCS7_DECRYPT_FAIL, + PKCS7_FILE_OPERATION_FAIL, } PKCS7_RetCode; typedef struct { diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/CMakeLists.txt b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/CMakeLists.txt new file mode 100644 index 000000000..6e384453e --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/CMakeLists.txt @@ -0,0 +1,45 @@ +#=============================================================================== +# @brief cmake file +# Copyright (c) CompanyNameMagicTag 2022-2023. All rights reserved. +#=============================================================================== +set(COMPONENT_NAME "cipher_static") + +set(PUBLIC_HEADER +) + +set(PRIVATE_HEADER + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${ROOT_DIR}/open_source/mbedtls/mbedtls_v3.6.0/include + ${OHOS_DIR}/commonlibrary/utils_lite/include +) + +set(SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/src/cipher_sha256.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cipher_aes.c +) + +set(COMPONENT_PUBLIC_CCFLAGS +) + +set(COMPONENT_CCFLAGS + -Wno-format-extra-args +) + +set(COMPONENT_CXXCFLAGS +) + +set(PUBLIC_DEFINES +) + +set(PRIVATE_DEFINES +) + +set(WHOLE_LINK + true +) + +set(MAIN_COMPONENT + false +) + +build_component() diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/include/cipher.h b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/include/cipher.h new file mode 100644 index 000000000..238034344 --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/include/cipher.h @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2020 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CIPHER_H +#define CIPHER_H + +#ifdef __cplusplus +#include +#include +#else +#include +#include +#endif + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#define KEY_LEN 16 // AES128 key length 16, AES256 key length 32 +#define AES_BLOCK_SIZE 16 +#define ERROR_CODE_GENERAL (-1) +#define ERROR_SUCCESS 0 + +typedef struct Sha256Context Sha256Context; + +typedef enum { + CIPHER_AES_ECB, + CIPHER_AES_CBC +} CipherAesMode; + +// 定义填充模式枚举 +typedef enum { + PADDING_PKCS5 = 0, + PADDING_PKCS7 = 1, + PADDING_NONE = 2 +} PaddingMode; + +typedef struct { + char *text; + char *key; + int32_t action; + int32_t textLen; + int32_t keyLen; +} CryptData; + +typedef struct { + char *transformation; + char *ivBuf; + int32_t ivOffset; + int32_t ivLen; +} AesIvMode; + +typedef struct { + CryptData data; + CipherAesMode mode; + AesIvMode iv; + PaddingMode paddingMode; +} AesCryptContext; + +typedef struct { + char *data; + size_t length; +} RsaData; + +typedef struct { + char *trans; + char *action; + char *key; + size_t keyLen; +} RsaKeyData; + +// ohos begin +// Add software sha256 and AES interface +Sha256Context* CreateSha256Context(void); +void DestroySha256Context(Sha256Context** ctx); +int32_t Sha256(const unsigned char *input, int ilen, unsigned char output[32]); +void Sha256Starts(Sha256Context *ctx); +int32_t Sha256Update(Sha256Context *ctx, const unsigned char *input, size_t ilen); +void Sha256Finish(Sha256Context *ctx, unsigned char output[32]); +// ohos end +int32_t InitAesCryptData(const char *action, const char *text, const char *key, + const AesIvMode *iv, AesCryptContext *aesCryptCxt); +int32_t CipherAesCrypt(AesCryptContext *aesCryptCxt); +void DeinitAesCryptData(AesCryptContext *aesCryptCxt); +int32_t RsaCrypt(RsaKeyData *key, RsaData *inData, RsaData *outData); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/include/cipher_log.h b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/include/cipher_log.h new file mode 100644 index 000000000..14a694216 --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/include/cipher_log.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CIPHER_LOG_H +#define CIPHER_LOG_H + +#include "securec.h" + +#ifdef __cplusplus +#include +#else +#include +#endif + +#undef LOG_TAG +#define LOG_TAG "CIPHER" +#undef LOG_DOMAIN +#define LOG_DOMAIN 0xD002F10 /* Security subsystem crypto framework domain id */ + + +enum CipherLogLevel { + CIPHER_LOG_LEVEL_E, +}; + +#ifdef __cplusplus +extern "C" { +#endif + +void CipherLog(uint32_t logLevel, const char *funcName, uint32_t lineNo, const char *format, ...); + +#ifndef __LITEOS__ +#define CIPHER_LOG_E(...) CipherLog(CIPHER_LOG_LEVEL_E, __func__, __LINE__, __VA_ARGS__) +#else +#define CIPHER_LOG_E printf +#endif +#ifdef __cplusplus +} +#endif + +#endif // CIPHER_LOG_H diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/src/cipher_aes.c b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/src/cipher_aes.c new file mode 100644 index 000000000..6adffd746 --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/src/cipher_aes.c @@ -0,0 +1,598 @@ +/* + * Copyright (c) 2025-2030 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include +#include +#include "cipher.h" +#include "securec.h" +#include "cipher_log.h" + +#define AES_BYTE_SIZE 128 +#define MAX_BUFFER_SIZE (1024 * 16) +#define KEY_LEN 16 // 128-bit key + +// 通用填充函数 +static int32_t AddPadding(char *data, int32_t dataLen, PaddingMode paddingMode) +{ + if (data == NULL || dataLen < 0) { + return ERROR_CODE_GENERAL; + } + + if (paddingMode == PADDING_NONE) { + return dataLen; + } + + int pad_len = AES_BLOCK_SIZE - (dataLen % AES_BLOCK_SIZE); + if (pad_len == AES_BLOCK_SIZE) { + pad_len = (paddingMode == PADDING_NONE) ? 0 : AES_BLOCK_SIZE; + } + + if (pad_len > 0) { + for (int i = 0; i < pad_len; i++) { + data[dataLen + i] = (char)pad_len; + } + } + return dataLen + pad_len; +} + +// 通用解填充函数 +static int32_t RemovePadding(char *data, int32_t dataLen, PaddingMode paddingMode) +{ + if (data == NULL || dataLen <= 0) { + return ERROR_CODE_GENERAL; + } + + if (paddingMode == PADDING_NONE) { + return dataLen; + } + + if (dataLen % AES_BLOCK_SIZE != 0) { + return ERROR_CODE_GENERAL; + } + + uint8_t pad_len = data[dataLen - 1]; + if (pad_len < 1 || pad_len > AES_BLOCK_SIZE) { + return ERROR_CODE_GENERAL; + } + + for (int i = 1; i <= pad_len; i++) { + if (data[dataLen - i] != pad_len) { + return ERROR_CODE_GENERAL; + } + } + return dataLen - pad_len; +} + +// 解析填充模式和加密模式 +static PaddingMode ParsePaddingModeAndType(const char *transformation, CipherAesMode *mode) +{ + PaddingMode padding = PADDING_PKCS5; // 默认PKCS5 + *mode = CIPHER_AES_CBC; // 默认CBC模式 + + if (transformation == NULL) { + return padding; + } + + // 检测填充模式 + if (strstr(transformation, "PKCS5Padding") != NULL) { + padding = PADDING_PKCS5; + } else if (strstr(transformation, "PKCS7Padding") != NULL) { + padding = PADDING_PKCS7; + } else if (strstr(transformation, "NoPadding") != NULL) { + padding = PADDING_NONE; + } + + // 检测加密模式 + if (strstr(transformation, "ECB") != NULL) { + *mode = CIPHER_AES_ECB; + } else if (strstr(transformation, "CBC") != NULL) { + *mode = CIPHER_AES_CBC; + } + + return padding; +} + +static char *MallocDecodeData(const char *text, size_t *olen) +{ + if (text == NULL) { + return NULL; + } + + size_t inputLen = strlen(text); + size_t decodeLen = 0; + int32_t ret = mbedtls_base64_decode(NULL, 0, &decodeLen, (const unsigned char *)text, inputLen); + if (ret != MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL) { + return NULL; + } + + if (decodeLen == 0) { + return NULL; + } + + // 分配精确长度,不添加额外终止符 + char *decData = (char *)malloc(decodeLen); + if (decData == NULL) { + CIPHER_LOG_E("malloc failed, length:%zu.\n", decodeLen); + return NULL; + } + + if (mbedtls_base64_decode((unsigned char *)decData, decodeLen, olen, + (const unsigned char *)text, inputLen) != 0) { + free(decData); + CIPHER_LOG_E("decode data failed, text:%s.\n", text); + return NULL; + } + + return decData; +} + +static char *MallocEncodeData(const unsigned char *text, size_t inputLen, size_t *outLen) +{ + if (text == NULL || inputLen == 0) { + return NULL; + } + + size_t encodeLen = 0; + int32_t ret = mbedtls_base64_encode(NULL, 0, &encodeLen, text, inputLen); + if (ret != MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL) { + return NULL; + } + + if (encodeLen == 0) { + return NULL; + } + + char *encData = (char *)malloc(encodeLen + 1); + if (encData == NULL) { + CIPHER_LOG_E("malloc data failed, expect len:%zu.\n", encodeLen); + return NULL; + } + + (void)memset_s(encData, encodeLen + 1, 0, encodeLen + 1); + if (mbedtls_base64_encode((unsigned char *)encData, encodeLen, outLen, text, inputLen) != 0) { + CIPHER_LOG_E("encode data failed.\n"); + free(encData); + return NULL; + } + + return encData; +} + +// 使用二进制数据处理IV +static int32_t SetIv(const unsigned char *ivBuf, size_t ivBufSize, int32_t ivOffset, int32_t ivLen, AesCryptContext *ctx) +{ + if (ctx == NULL) { + CIPHER_LOG_E("SetIv: NULL context\n"); + return ERROR_CODE_GENERAL; + } + + // ECB模式不需要IV + if (ctx->mode == CIPHER_AES_ECB) { + ctx->iv.ivBuf = NULL; + ctx->iv.ivLen = 0; + ctx->iv.ivOffset = 0; + return ERROR_SUCCESS; + } + + if (ivBuf == NULL) { + CIPHER_LOG_E("SetIv: NULL ivBuf\n"); + return ERROR_CODE_GENERAL; + } + + if (ivOffset < 0 || ivLen <= 0) { + CIPHER_LOG_E("ivLen or ivOffset negative err.\n"); + return ERROR_CODE_GENERAL; + } + + if (ivBufSize < (size_t)(ivOffset + ivLen)) { + CIPHER_LOG_E("ivBufSize too small: %zu < %d\n", + ivBufSize, ivOffset + ivLen); + return ERROR_CODE_GENERAL; + } + + ctx->iv.ivBuf = malloc(ivLen); + if (ctx->iv.ivBuf == NULL) { + CIPHER_LOG_E("malloc failed for IV.\n"); + return ERROR_CODE_GENERAL; + } + + int32_t ret = memcpy_s(ctx->iv.ivBuf, ivLen, ivBuf + ivOffset, ivLen); + if (ret != EOK) { + CIPHER_LOG_E("memcpy failed, ret:%d.\n", ret); + free(ctx->iv.ivBuf); + ctx->iv.ivBuf = NULL; + return ERROR_CODE_GENERAL; + } + + ctx->iv.ivLen = ivLen; + return ERROR_SUCCESS; +} + +static int32_t InitAesCryptContext(const char *key, const AesIvMode *iv, AesCryptContext *ctx) +{ + int32_t ret; + if (iv == NULL || ctx == NULL || key == NULL) { + CIPHER_LOG_E("InitAesCryptContext: NULL parameter\n"); + return ERROR_CODE_GENERAL; + } + + // 解析填充模式和加密模式 + ctx->paddingMode = ParsePaddingModeAndType(iv->transformation, &ctx->mode); + + ctx->iv.ivOffset = iv->ivOffset; + ctx->iv.ivLen = (ctx->mode == CIPHER_AES_CBC) ? AES_BLOCK_SIZE : 0; + + // ECB模式不需要IV长度检查 + if (ctx->mode == CIPHER_AES_CBC) { + if (iv->ivLen != AES_BLOCK_SIZE) { + CIPHER_LOG_E("ivLen:%d error, need be %d Bytes.\n", + iv->ivLen, AES_BLOCK_SIZE); + return ERROR_CODE_GENERAL; + } + + // 处理Base64编码的IV + if (iv->ivBuf != NULL) { + size_t decodedIvLen = 0; + char* decodedIvBuf = MallocDecodeData(iv->ivBuf, &decodedIvLen); + if (decodedIvBuf == NULL) { + CIPHER_LOG_E("base64 decode failed for IV.\n"); + return ERROR_CODE_GENERAL; + } + + // 使用二进制数据设置IV + ret = SetIv((const unsigned char *)decodedIvBuf, decodedIvLen, + ctx->iv.ivOffset, ctx->iv.ivLen, ctx); + free(decodedIvBuf); + + if (ret != ERROR_SUCCESS) { + CIPHER_LOG_E("SetIv failed after decoding, ret:%d.\n", ret); + return ERROR_CODE_GENERAL; + } + } else { + // 直接使用二进制密钥数据 + if (ctx->data.key == NULL) { + CIPHER_LOG_E("Key is NULL when using as IV\n"); + return ERROR_CODE_GENERAL; + } + + ret = SetIv((const unsigned char *)ctx->data.key, ctx->data.keyLen, + ctx->iv.ivOffset, ctx->iv.ivLen, ctx); + if (ret != ERROR_SUCCESS) { + CIPHER_LOG_E("SetIv from key failed, ret:%d.\n", ret); + return ERROR_CODE_GENERAL; + } + } + } else { + // ECB模式不需要IV + ctx->iv.ivBuf = NULL; + ctx->iv.ivLen = 0; + } + return ERROR_SUCCESS; +} + +static int32_t InitAesCryptDataText(const char *action, const char *key, const char *text, CryptData *data, PaddingMode paddingMode) +{ + if (action == NULL || text == NULL || data == NULL) { + CIPHER_LOG_E("InitAesCryptDataText: NULL parameter\n"); + return ERROR_CODE_GENERAL; + } + + if (strcmp(action, "encrypt") == 0) { + data->action = MBEDTLS_AES_ENCRYPT; + int32_t originalLen = strlen(text); + + // 计算填充后长度 + int32_t paddedLen; + if (paddingMode == PADDING_NONE) { + paddedLen = originalLen; + // 无填充模式需要长度是块大小的倍数 + if (paddedLen % AES_BLOCK_SIZE != 0) { + CIPHER_LOG_E("Text length %d not multiple of block size for NoPadding\n", paddedLen); + return ERROR_CODE_GENERAL; + } + } else { + int pad_len = AES_BLOCK_SIZE - (originalLen % AES_BLOCK_SIZE); + pad_len = (pad_len == 0) ? AES_BLOCK_SIZE : pad_len; + paddedLen = originalLen + pad_len; + } + + if (paddedLen <= 0) { + CIPHER_LOG_E("Invalid padded length: %d\n", paddedLen); + return ERROR_CODE_GENERAL; + } + + data->text = malloc(paddedLen + 1); + if (data->text == NULL) { + CIPHER_LOG_E("malloc failed for text\n"); + return ERROR_CODE_GENERAL; + } + + (void)memset_s(data->text, paddedLen + 1, 0, paddedLen + 1); + + if (memcpy_s(data->text, paddedLen + 1, text, originalLen) != EOK) { + CIPHER_LOG_E("memcpy_s failed for text\n"); + free(data->text); + data->text = NULL; + return ERROR_CODE_GENERAL; + } + + // 添加填充 + if (paddingMode != PADDING_NONE) { + data->textLen = AddPadding(data->text, originalLen, paddingMode); + if (data->textLen != paddedLen) { + CIPHER_LOG_E("Padding failed: expected %d, got %d\n", paddedLen, data->textLen); + free(data->text); + data->text = NULL; + return ERROR_CODE_GENERAL; + } + } else { + data->textLen = paddedLen; + } + } else if (strcmp(action, "decrypt") == 0) { + data->action = MBEDTLS_AES_DECRYPT; + size_t textLen = 0; + data->text = MallocDecodeData(text, &textLen); + if (data->text == NULL) { + CIPHER_LOG_E("Base64 decode failed for ciphertext\n"); + return ERROR_CODE_GENERAL; + } + data->textLen = (uint32_t)textLen; + + // 无填充模式不需要对齐块大小 + if (paddingMode != PADDING_NONE) { + // 确保数据长度是块大小的整数倍 + if (data->textLen % AES_BLOCK_SIZE != 0) { + CIPHER_LOG_E("Ciphertext length %d not multiple of block size\n", data->textLen); + free(data->text); + data->text = NULL; + return ERROR_CODE_GENERAL; + } + } + } else { + CIPHER_LOG_E("Invalid action: %s\n", action); + return ERROR_CODE_GENERAL; + } + return ERROR_SUCCESS; +} + +static int32_t InitAesData(const char *action, const char *key, const char *text, CryptData *data, PaddingMode paddingMode) +{ + if (action == NULL || text == NULL || data == NULL || key == NULL) { + CIPHER_LOG_E("InitAesData: NULL parameter\n"); + return ERROR_CODE_GENERAL; + } + + // 先初始化文本数据 + int32_t ret = InitAesCryptDataText(action, key, text, data, paddingMode); + if (ret != ERROR_SUCCESS) { + CIPHER_LOG_E("InitAesCryptDataText failed\n"); + return ERROR_CODE_GENERAL; + } + + // 解码Base64编码的密钥 + size_t keyLen = 0; + data->key = MallocDecodeData(key, &keyLen); + if (data->key == NULL) { + CIPHER_LOG_E("Base64 decode failed for key\n"); + goto ERROR; + } + + // 验证密钥长度(使用实际解码长度) + if (keyLen != KEY_LEN) { + CIPHER_LOG_E("key length:%zu error, need be %d Bytes.\n", keyLen, KEY_LEN); + (void)memset_s(data->key, keyLen, 0, keyLen); + free(data->key); + data->key = NULL; + goto ERROR; + } + + // 使用实际解码长度 + data->keyLen = keyLen; + return ERROR_SUCCESS; + +ERROR: + if (data->text != NULL) { + free(data->text); + data->text = NULL; + } + return ERROR_CODE_GENERAL; +} + +void DeinitAesCryptData(AesCryptContext *aesCryptCxt) +{ + if (aesCryptCxt == NULL) { + return; + } + + if (aesCryptCxt->iv.ivBuf != NULL) { + free(aesCryptCxt->iv.ivBuf); + aesCryptCxt->iv.ivBuf = NULL; + } + + if (aesCryptCxt->data.key != NULL) { + (void)memset_s(aesCryptCxt->data.key, aesCryptCxt->data.keyLen, 0, aesCryptCxt->data.keyLen); + free(aesCryptCxt->data.key); + aesCryptCxt->data.key = NULL; + } + + if (aesCryptCxt->data.text != NULL) { + free(aesCryptCxt->data.text); + aesCryptCxt->data.text = NULL; + } +} + +static int32_t DoAesCbcEncrypt(mbedtls_aes_context *aesCtx, AesCryptContext *ctx) +{ + int32_t ret; + if (ctx->data.action == MBEDTLS_AES_ENCRYPT) { + ret = mbedtls_aes_setkey_enc(aesCtx, (const unsigned char *)ctx->data.key, AES_BYTE_SIZE); + } else { + ret = mbedtls_aes_setkey_dec(aesCtx, (const unsigned char *)ctx->data.key, AES_BYTE_SIZE); + } + if (ret != 0) { + CIPHER_LOG_E("aes setkey error, ret:%d.\n", ret); + return ERROR_CODE_GENERAL; + } + + ret = mbedtls_aes_crypt_cbc(aesCtx, ctx->data.action, ctx->data.textLen, + (unsigned char *)ctx->iv.ivBuf, (const unsigned char *)ctx->data.text, (unsigned char *)ctx->data.text); + if (ret != 0) { + CIPHER_LOG_E("aes crypt cbc error, ret:%d.\n", ret); + return ERROR_CODE_GENERAL; + } + + if (ctx->data.action == MBEDTLS_AES_ENCRYPT) { + size_t textLen = ctx->data.textLen; + char *out = MallocEncodeData((const unsigned char *)ctx->data.text, textLen, &textLen); + if (out == NULL) { + CIPHER_LOG_E("base64 encode failed.\n"); + return ERROR_CODE_GENERAL; + } + ctx->data.textLen = (uint32_t)textLen; + free(ctx->data.text); + ctx->data.text = out; + } else { + // 使用上下文中的填充模式进行解填充 + int32_t unpaddedLen = RemovePadding(ctx->data.text, ctx->data.textLen, ctx->paddingMode); + if (unpaddedLen < 0) { + CIPHER_LOG_E("remove padding failed.\n"); + return ERROR_CODE_GENERAL; + } + ctx->data.textLen = unpaddedLen; + + // 添加字符串终止符 + ctx->data.text[unpaddedLen] = '\0'; + } + + return ERROR_SUCCESS; +} + +// ECB模式加解密函数 +static int32_t DoAesEcbEncrypt(mbedtls_aes_context *aesCtx, AesCryptContext *ctx) +{ + int32_t ret; + if (ctx->data.action == MBEDTLS_AES_ENCRYPT) { + ret = mbedtls_aes_setkey_enc(aesCtx, (const unsigned char *)ctx->data.key, AES_BYTE_SIZE); + } else { + ret = mbedtls_aes_setkey_dec(aesCtx, (const unsigned char *)ctx->data.key, AES_BYTE_SIZE); + } + if (ret != 0) { + CIPHER_LOG_E("aes setkey error, ret:%d.\n", ret); + return ERROR_CODE_GENERAL; + } + + // ECB模式需要分块处理 + int32_t blockCount = ctx->data.textLen / AES_BLOCK_SIZE; + for (int i = 0; i < blockCount; i++) { + uint8_t input[AES_BLOCK_SIZE]; + uint8_t output[AES_BLOCK_SIZE]; + memcpy(input, ctx->data.text + i * AES_BLOCK_SIZE, AES_BLOCK_SIZE); + + ret = mbedtls_aes_crypt_ecb(aesCtx, ctx->data.action, input, output); + if (ret != 0) { + CIPHER_LOG_E("aes crypt ecb error at block %d, ret:%d.\n", i, ret); + return ERROR_CODE_GENERAL; + } + + memcpy(ctx->data.text + i * AES_BLOCK_SIZE, output, AES_BLOCK_SIZE); + } + + if (ctx->data.action == MBEDTLS_AES_ENCRYPT) { + size_t textLen = ctx->data.textLen; + char *out = MallocEncodeData((const unsigned char *)ctx->data.text, textLen, &textLen); + if (out == NULL) { + CIPHER_LOG_E("base64 encode failed.\n"); + return ERROR_CODE_GENERAL; + } + ctx->data.textLen = (uint32_t)textLen; + free(ctx->data.text); + ctx->data.text = out; + } else { + // 使用上下文中的填充模式进行解填充 + int32_t unpaddedLen = RemovePadding(ctx->data.text, ctx->data.textLen, ctx->paddingMode); + if (unpaddedLen < 0) { + CIPHER_LOG_E("remove padding failed.\n"); + return ERROR_CODE_GENERAL; + } + ctx->data.textLen = unpaddedLen; + + // 添加字符串终止符 + ctx->data.text[unpaddedLen] = '\0'; + } + + return ERROR_SUCCESS; +} + +int32_t InitAesCryptData(const char *action, const char *text, const char *key, const AesIvMode *iv, + AesCryptContext *aesCryptCxt) +{ + if (action == NULL || text == NULL || key == NULL || iv == NULL || aesCryptCxt == NULL) { + CIPHER_LOG_E("InitAesCryptData: NULL parameter\n"); + return ERROR_CODE_GENERAL; + } + + // 初始化填充模式和加密模式 + aesCryptCxt->paddingMode = ParsePaddingModeAndType(iv->transformation, &aesCryptCxt->mode); + + // 初始化数据 + int32_t ret = InitAesData(action, key, text, &(aesCryptCxt->data), aesCryptCxt->paddingMode); + if (ret != ERROR_SUCCESS) { + CIPHER_LOG_E("InitAesData failed, ret:%d.\n", ret); + DeinitAesCryptData(aesCryptCxt); + return ERROR_CODE_GENERAL; + } + + // 初始化上下文(包括IV) + ret = InitAesCryptContext(key, iv, aesCryptCxt); + if (ret != ERROR_SUCCESS) { + CIPHER_LOG_E("InitAesCryptContext failed, ret:%d.\n", ret); + DeinitAesCryptData(aesCryptCxt); + return ERROR_CODE_GENERAL; + } + return ERROR_SUCCESS; +} + +int32_t CipherAesCrypt(AesCryptContext* aesCryptCxt) +{ + if (aesCryptCxt == NULL) { + CIPHER_LOG_E("AesCrypt: NULL context\n"); + return ERROR_CODE_GENERAL; + } + + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + int32_t ret = ERROR_CODE_GENERAL; + + if (aesCryptCxt->mode == CIPHER_AES_CBC) { + ret = DoAesCbcEncrypt(&aes, aesCryptCxt); + if (ret != ERROR_SUCCESS) { + CIPHER_LOG_E("Aes cbc crypt failed, ret:%d.\n", ret); + } + } else if (aesCryptCxt->mode == CIPHER_AES_ECB) { + ret = DoAesEcbEncrypt(&aes, aesCryptCxt); + if (ret != ERROR_SUCCESS) { + CIPHER_LOG_E("Aes ecb crypt failed, ret:%d.\n", ret); + } + } else { + CIPHER_LOG_E("unsupported crypt mode: %d\n", aesCryptCxt->mode); + } + + mbedtls_aes_free(&aes); + return ret; +} \ No newline at end of file diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/src/cipher_sha256.c b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/src/cipher_sha256.c new file mode 100644 index 000000000..8abb8cd4d --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/src/cipher_sha256.c @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2025-2030 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// ohos begin +// Add software sha256 and AES interface +#include "cipher.h" +#include "mbedtls/sha256.h" + +#define SHA256_HASH_SIZE 32 + +struct Sha256Context { + mbedtls_sha256_context mbed_ctx; +}; + +Sha256Context* CreateSha256Context(void) +{ + Sha256Context* ctx = malloc(sizeof(Sha256Context)); + mbedtls_sha256_init(&ctx->mbed_ctx); + return ctx; +} + +void DestroySha256Context(Sha256Context** ctx) +{ + if (*ctx) { + mbedtls_sha256_free(&(*ctx)->mbed_ctx); + free(*ctx); + *ctx = NULL; + } +} + +void Sha256Starts(Sha256Context *ctx) +{ + mbedtls_sha256_starts(&ctx->mbed_ctx, 0); // 0 represents SHA-256 +} + +int32_t Sha256Update(Sha256Context *ctx, const unsigned char *input, size_t ilen) +{ + return mbedtls_sha256_update(&ctx->mbed_ctx, input, ilen); +} + +void Sha256Finish(Sha256Context *ctx, unsigned char output[SHA256_HASH_SIZE]) +{ + mbedtls_sha256_finish(&ctx->mbed_ctx, output); +} + +int32_t Sha256(const unsigned char *input, int ilen, unsigned char output[SHA256_HASH_SIZE]) +{ + return mbedtls_sha256(input, (size_t)ilen, output, 0); +} +// ohos end \ No newline at end of file diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/CMakeLists.txt b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/CMakeLists.txt new file mode 100644 index 000000000..96ddbb304 --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/CMakeLists.txt @@ -0,0 +1,49 @@ +#=============================================================================== +# @brief cmake file +# Copyright (c) CompanyNameMagicTag 2022-2023. All rights reserved. +#=============================================================================== +set(COMPONENT_NAME "ace_kit_cipher_static") + +set(PUBLIC_HEADER +) + +set(PRIVATE_HEADER + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${ROOT_DIR}/open_source/openharmony/base/security/huks/frameworks/crypto_lite/cipher/include + ${ROOT_DIR}/open_source/mbedtls/mbedtls_v3.6.0/include + ${ROOT_DIR}/foundation/arkui/ace_engine_lite/interfaces/jsi + ${ROOT_DIR}/foundation/arkui/ace_engine_lite/interfaces/base + ${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/interfaces/base +) + +set(SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/src/cipher_module.cpp +) + +set(COMPONENT_PUBLIC_CCFLAGS +) + +set(COMPONENT_CCFLAGS + -std=c++11 +) + +set(COMPONENT_CXXCFLAGS +) + +set(PUBLIC_DEFINES +) + +set(PRIVATE_DEFINES + HUKS_LITEWEARABLE_SUPPORT_ENABLED +) + +set(WHOLE_LINK + true +) + +set(MAIN_COMPONENT + false +) + +build_component() + diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/include/cipher_module.h b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/include/cipher_module.h new file mode 100644 index 000000000..5a530ecd4 --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/include/cipher_module.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2020 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ACELITE_CIPHER_MODULE_H +#define OHOS_ACELITE_CIPHER_MODULE_H + +#include "jsi.h" +#include "cipher.h" + +namespace OHOS { +namespace ACELite { +class CipherModule final : public MemoryHeap { +public: + CipherModule() {} + ~CipherModule() {} + static JSIValue Rsa(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue Aes(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + static JSIValue Sha256All(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue Sha256SubStarts(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue Sha256SubUpdate(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue Sha256SubFinish(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static void OnDestroy(); +#endif +private: + static constexpr uint8_t ERR_CODE = 200; + static void ResetStrBuf(char *strBuf); + static CipherAesMode GetMode(char *strTransformation); + static PaddingMode GetPaddingMode(char *strTransformation); +}; + +void InitCipherModule(JSIValue exports); +} // namespace ACELite +} // namespace OHOS +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED +int32_t CipherMsgToJS(const char *msgBody, OHOS::ACELite::JSIValue context, OHOS::ACELite::JSIValue callback); +#endif +#endif // OHOS_ACELITE_CIPHER_MODULE_H diff --git a/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/src/cipher_module.cpp b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/src/cipher_module.cpp new file mode 100644 index 000000000..c2a067550 --- /dev/null +++ b/code/sdk/open_source/openharmony/base/security/huks/frameworks/crypto_lite/js/builtin/src/cipher_module.cpp @@ -0,0 +1,483 @@ +/* + * Copyright (c) 2020 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cipher_module.h" +#include "log.h" +#include "securec.h" +// OHOS BEGIN +#include +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED +#include "mbedtls/sha256.h" +#include "js_async_work.h" +#endif + +const int8_t SHA256_LEN = 32; +const int8_t SHA256_RESULT_LEN = SHA256_LEN * 2; +const int32_t MAX_LEN = 16384; + +struct CipherMsgParams { + char *msgBody; + uint8_t type; + OHOS::ACELite::JSIValue context; + OHOS::ACELite::JSIValue callback; + bool flag; +}; +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED +struct Sha256Context { + mbedtls_sha256_context context; +}; + +Sha256Context *g_sha256Context; +#endif +// OHOS END +namespace OHOS { +namespace ACELite { +JSIValue CipherModule::Rsa(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + JSIValue undefValue = JSI::CreateUndefined(); + if ((args == nullptr) || argsNum == 0 || JSI::ValueIsUndefined(args[0])) { + return undefValue; + } + + JSIValue success = JSI::GetNamedProperty(args[0], CB_SUCCESS); + JSIValue fail = JSI::GetNamedProperty(args[0], CB_FAIL); + JSIValue complete = JSI::GetNamedProperty(args[0], CB_COMPLETE); + char *strAction = JSI::GetStringProperty(args[0], "action"); + char *strKey = JSI::GetStringProperty(args[0], "key"); + char *strText = JSI::GetStringProperty(args[0], "text"); + char *strTransformation = JSI::GetStringProperty(args[0], "transformation"); + JSIValue code = JSI::CreateNumber(ERR_CODE); + JSIValue data = JSI::CreateString("System error"); + JSIValue argvFail[ARGC_TWO] = { data, code }; + JSIValue result = JSI::CreateObject(); + JSIValue argvSuccess[ARGC_ONE] = { result }; + int ret = ERROR_CODE_GENERAL; + RsaData textIn = { NULL, 0 }; + RsaData textOut = { NULL, 0 }; + RsaKeyData rsaKey = { NULL, NULL, NULL, 0 }; + if ((strKey == nullptr) || (strText == nullptr)) { + JSI::CallFunction(fail, thisVal, argvFail, ARGC_TWO); + goto RELEASE; + } + rsaKey.key = strKey; + rsaKey.keyLen = strlen(strKey); + rsaKey.trans = strTransformation; + rsaKey.action = strAction; + textIn.data = strText; + textIn.length = strlen(strText); + + ret = RsaCrypt(&rsaKey, &textIn, &textOut); + if ((ret != ERROR_SUCCESS) || (textOut.length == 0)) { + HILOG_ERROR(HILOG_MODULE_ACE, "RsaCrypt failed."); + JSI::CallFunction(fail, thisVal, argvFail, ARGC_TWO); + goto RELEASE; + } + textOut.data = static_cast(ace_malloc(textOut.length)); + if (textOut.data == nullptr) { + HILOG_ERROR(HILOG_MODULE_ACE, "ace malloc failed."); + JSI::CallFunction(fail, thisVal, argvFail, ARGC_TWO); + goto RELEASE; + } + ret = memset_s(textOut.data, textOut.length, 0, textOut.length); + if (ret) { + HILOG_ERROR(HILOG_MODULE_ACE, "memset failed."); + } + ret = RsaCrypt(&rsaKey, &textIn, &textOut); + if (ret != ERROR_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_ACE, "RsaCrypt failed."); + JSI::CallFunction(fail, thisVal, argvFail, ARGC_TWO); + goto RELEASE; + } + JSI::SetStringProperty(result, "text", (char*)textOut.data); + JSI::CallFunction(success, thisVal, argvSuccess, ARGC_ONE); + +RELEASE: + JSI::ReleaseString(strAction); + JSI::ReleaseString(strText); + ResetStrBuf(strKey); + JSI::ReleaseString(strKey); + JSI::ReleaseString(strTransformation); + JSI::CallFunction(complete, thisVal, nullptr, 0); + JSI::ReleaseValueList(success, fail, complete, result, code, data, ARGS_END); + if (textOut.data != nullptr) { + ace_free(textOut.data); + } + + return undefValue; +} +// OHOS BEGIN +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED +JSIValue CipherModule::Sha256All(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + JSIValue undefValue = JSI::CreateUndefined(); + if ((args == nullptr) || argsNum == 0 || JSI::ValueIsUndefined(args[0])) { + HILOG_ERROR(HILOG_MODULE_ACE, "Sha256 args error."); + return undefValue; + } + JSIValue context = JSI::AcquireValue(thisVal); + JSIValue success = JSI::GetNamedProperty(args[0], CB_SUCCESS); + JSIValue fail = JSI::GetNamedProperty(args[0], CB_FAIL); + char *strText = JSI::GetStringProperty(args[0], "text"); + unsigned char sha256Result[SHA256_LEN]; + unsigned char *strResult = reinterpret_cast(strText); + int32_t ret = -1; + int size = 2; + int sizeBuffer = 3; + if (strlen(strText) == 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "args error , text is nullptr"); + goto RELEASE; + } + ret = Sha256(strResult, strlen(strText), sha256Result); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Sha256 error."); + CipherMsgToJS("Sha256All error", context, fail); + goto RELEASE; + } + char result[SHA256_RESULT_LEN + 1]; + for (int i = 0; i < SHA256_LEN; i++) { + ret = sprintf_s(&result[i * size], sizeBuffer, "%02x", sha256Result[i]); + if (ret < 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Sha256All sprintf_s error."); + goto RELEASE; + } + } + result[SHA256_RESULT_LEN] = '\0'; + ret = CipherMsgToJS(result, context, success); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Sha256All send message error."); + CipherMsgToJS("Sha256All send message error error", context, fail); + goto RELEASE; + } + +RELEASE: + JSI::ReleaseString(strText); + return undefValue; +} + +JSIValue CipherModule::Sha256SubStarts(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + g_sha256Context = CreateSha256Context(); + Sha256Starts(g_sha256Context); + return JSI::CreateUndefined(); +} + +JSIValue CipherModule::Sha256SubUpdate(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + JSIValue undefValue = JSI::CreateUndefined(); + if ((args == nullptr) || argsNum == 0 || JSI::ValueIsUndefined(args[0])) { + HILOG_ERROR(HILOG_MODULE_ACE, "args error."); + return undefValue; + } + char *strText = JSI::ValueToString(args[0]); + if (strlen(strText) == 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "args error , text is nullptr"); + JSI::ReleaseString(strText); + return undefValue; + } + unsigned char *strTemp = reinterpret_cast(strText); + Sha256Update(g_sha256Context, strTemp, strlen(strText)); + JSI::ReleaseString(strText); + return undefValue; +} + +JSIValue CipherModule::Sha256SubFinish(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + JSIValue undefValue = JSI::CreateUndefined(); + if ((args == nullptr) || argsNum == 0 || JSI::ValueIsUndefined(args[0])) { + HILOG_ERROR(HILOG_MODULE_ACE, "args error."); + return undefValue; + } + JSIValue context = JSI::AcquireValue(thisVal); + JSIValue success = JSI::GetNamedProperty(args[0], CB_SUCCESS); + JSIValue fail = JSI::GetNamedProperty(args[0], CB_FAIL); + unsigned char sha256Result[SHA256_LEN]; + char result[SHA256_RESULT_LEN + 1]; + Sha256Finish(g_sha256Context, sha256Result); + int32_t ret = 0; + int size = 2; + int sizeBuffer = 3; + for (int i = 0; i < SHA256_LEN; i++) { + ret = sprintf_s(&result[i * size], sizeBuffer, "%02x", sha256Result[i]); + if (ret < 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Sha256SubFinish sprintf_s error."); + return undefValue; + } + } + result[SHA256_RESULT_LEN] = '\0'; + ret = CipherMsgToJS(result, context, success); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Sha256SubFinish send message error."); + CipherMsgToJS("Sha256SubFinish error", context, fail); + } + DestroySha256Context(&g_sha256Context); + return undefValue; +} +#endif +// OHOS END +JSIValue CipherModule::Aes(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + JSIValue undefValue = JSI::CreateUndefined(); + if ((args == nullptr) || argsNum == 0 || JSI::ValueIsUndefined(args[0])) { + HILOG_ERROR(HILOG_MODULE_ACE, "args error."); + return undefValue; + } +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + JSIValue context = JSI::AcquireValue(thisVal); +#endif + JSIValue success = JSI::GetNamedProperty(args[0], CB_SUCCESS); + JSIValue fail = JSI::GetNamedProperty(args[0], CB_FAIL); + char *strAction = JSI::GetStringProperty(args[0], "action"); + char *strText = JSI::GetStringProperty(args[0], "text"); + char *strKey = JSI::GetStringProperty(args[0], "key"); + char *strTransformation = JSI::GetStringProperty(args[0], "transformation"); + char *strIv = JSI::GetStringProperty(args[0], "iv"); + double ivOffset = JSI::GetNumberProperty(args[0], "ivOffset"); + JSIValue jsIvLen = JSI::GetNamedProperty(args[0], "ivLen"); + JSIValue result = JSI::CreateObject(); + JSIValue code = JSI::CreateNumber(ERR_CODE); + JSIValue argvSuccess[ARGC_ONE] = { result }; + JSIValue data = JSI::CreateString("System error"); + JSIValue argvFail[ARGC_TWO] = { data, code }; + CipherAesMode mode = GetMode(strTransformation); + PaddingMode paddingMode = GetPaddingMode(strTransformation); + AesCryptContext aes = {{NULL, NULL, 0, 0, 0}, mode, {NULL, NULL, 0, 0}, paddingMode}; + AesIvMode iv = {NULL, NULL, 0, 0}; +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + std::string str; + int32_t textLen; +#endif + int ret; + double ivLen = -1; + if (strlen(strText) == 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "args error , text is nullptr"); + goto RELEASE; + } + if (!strcmp(strAction, "encrypt") && paddingMode == PADDING_NONE && strlen(strText) % AES_BLOCK_SIZE != 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "args error , text is not valid"); + goto RELEASE; + } + if (JSI::ValueIsNumber(jsIvLen)) { + ivLen = JSI::ValueToNumber(jsIvLen); + if (ivLen < 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Ivlen:%lf is not natural number.", ivLen); +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + CipherMsgToJS("Aes jsIvLen error", context, fail); +#else + JSI::CallFunction(fail, thisVal, argvFail, ARGC_TWO); +#endif + goto RELEASE; + } + } + + iv.ivBuf = strIv; + iv.ivLen = ivLen; + iv.ivOffset = ivOffset; + iv.transformation = strTransformation; + ret = InitAesCryptData(strAction, strText, strKey, &iv, &aes); + if (ret != ERROR_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_ACE, "InitAesCryptData failed."); +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + CipherMsgToJS("InitAesCryptData failed", context, fail); +#else + JSI::CallFunction(fail, thisVal, argvFail, ARGC_TWO); +#endif + goto RELEASE; + } + ret = CipherAesCrypt(&aes); + if (ret != ERROR_SUCCESS) { + HILOG_ERROR(HILOG_MODULE_ACE, "CipherAesCrypt failed."); +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + CipherMsgToJS("CipherAesCrypt failed", context, fail); +#else + JSI::CallFunction(fail, thisVal, argvFail, ARGC_TWO); +#endif + goto RELEASE; + } +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + str = aes.data.text; + textLen = aes.data.textLen; + ret = CipherMsgToJS(str.substr(0, textLen).c_str(), context, success); + if (ret != 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Aes send message error."); + CipherMsgToJS("Aes send message error.", context, fail); + } +#else + JSI::SetStringProperty(result, "text", (char*)aes.data.text); + JSI::CallFunction(success, thisVal, argvSuccess, ARGC_ONE); +#endif + +RELEASE: + JSI::ReleaseString(strAction); + JSI::ReleaseString(strText); + ResetStrBuf(strKey); + ResetStrBuf(strIv); + JSI::ReleaseString(strKey); + JSI::ReleaseString(strIv); + JSI::ReleaseString(strTransformation); + DeinitAesCryptData(&aes); + return undefValue; +} +// OHOS BEGIN +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED +void CipherModule::OnDestroy() +{ + if (g_sha256Context != nullptr) { + DestroySha256Context(&g_sha256Context); + g_sha256Context = nullptr; + } +} +#endif +// OHOS END +void CipherModule::ResetStrBuf(char *strBuf) +{ + if (strBuf == nullptr) { + return; + } + + int ret = memset_s(strBuf, strlen(strBuf), 0, strlen(strBuf)); + if (ret != EOK) { + HILOG_ERROR(HILOG_MODULE_ACE, "memset failed."); + } +} + +CipherAesMode CipherModule::GetMode(char *strTransformation) +{ + std::string str(strTransformation); + int firstIndex = str.find_first_of("/"); + int lastIndex = str.find_last_of("/"); + std::string substr = str.substr(firstIndex + 1, lastIndex - (firstIndex + 1)); + CipherAesMode result = CIPHER_AES_CBC; + if (substr == "ECB") { + result = CIPHER_AES_ECB; + } + return result; +} + +PaddingMode CipherModule::GetPaddingMode(char *strTransformation) +{ + PaddingMode result = PADDING_NONE; + if (!strcmp(strTransformation, "AES/CBC/PKCS5Padding") || !strcmp(strTransformation, "AES/ECB/PKCS5Padding")) { + result = PADDING_PKCS5; + } else if (!strcmp(strTransformation, "AES/CBC/PKCS7Padding") || + !strcmp(strTransformation, "AES/ECB/PKCS7Padding")) { + result = PADDING_PKCS7; + } + return result; +} + +// OHOS BEGIN +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED +static int32_t CopyStr(char **destStr, const char *srcStr) +{ + if (destStr == nullptr || srcStr == nullptr) { + return -1; + } + + uint32_t length = strlen(srcStr) + 1; + if (length > MAX_LEN) { + HILOG_ERROR(HILOG_MODULE_ACE, "More than Max Memory"); + return -1; + } + *destStr = static_cast(ace_malloc(length)); + if (*destStr == nullptr) { + HILOG_ERROR(HILOG_MODULE_ACE, "Failed to allocate memory for destination string"); + return -1; + } + + if (memset_s(*destStr, length, 0, length) != EOK) { + HILOG_ERROR(HILOG_MODULE_ACE, "Failed to set memory for destination string"); + ace_free(*destStr); + return -1; + } + if (memcpy_s(*destStr, length, srcStr, length) != EOK) { + HILOG_ERROR(HILOG_MODULE_ACE, "Failed to copy source string to destination string"); + ace_free(*destStr); + return -1; + } + + return 0; +} + +static void ExecuteSendMsgToJS(void *data) +{ + if (data == nullptr) { + return; + } + CipherMsgParams *params = static_cast(data); + + char *msgBody = params->msgBody; + OHOS::ACELite::JSIValue callback = params->callback; + OHOS::ACELite::JSIValue context = params->context; + delete params; + params = nullptr; + + OHOS::ACELite::JSIValue dataInfo = OHOS::ACELite::JSI::CreateString(msgBody); + OHOS::ACELite::JSIValue callbackArgv[OHOS::ACELite::ARGC_ONE] = {dataInfo}; + OHOS::ACELite::JSI::CallFunction(callback, context, callbackArgv, OHOS::ACELite::ARGC_ONE); + OHOS::ACELite::JSI::ReleaseValue(dataInfo); + ace_free(msgBody); + return; +} +#endif +// OHOS END + +void InitCipherModule(JSIValue exports) +{ + JSI::SetModuleAPI(exports, "aes", CipherModule::Aes); +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED + JSI::SetModuleAPI(exports, "sha", CipherModule::Sha256All); + JSI::SetModuleAPI(exports, "shaInit", CipherModule::Sha256SubStarts); + JSI::SetModuleAPI(exports, "shaUpdate", CipherModule::Sha256SubUpdate); + JSI::SetModuleAPI(exports, "shaFinal", CipherModule::Sha256SubFinish); + JSI::SetOnDestroy(exports, CipherModule::OnDestroy); +#endif +} + +} // namespace ACELite +} // namespace OHOS +// OHOS START +#ifdef HUKS_LITEWEARABLE_SUPPORT_ENABLED +int32_t CipherMsgToJS(const char *msgBody, OHOS::ACELite::JSIValue context, OHOS::ACELite::JSIValue callback) +{ + CipherMsgParams *params = new CipherMsgParams(); + if (params == nullptr) { + HILOG_ERROR(HILOG_MODULE_ACE, "Failed to allocate memory for params"); + return -1; + } + params->context = context; + params->callback = callback; + int32_t copyRet = OHOS::ACELite::CopyStr(¶ms->msgBody, msgBody); + if (copyRet != 0) { + HILOG_ERROR(HILOG_MODULE_ACE, "Failed to copy msgBody"); + OHOS::ACELite::ace_free(params->msgBody); + params->msgBody = nullptr; + delete params; + params = nullptr; + return copyRet; + } + bool ret = + OHOS::ACELite::JsAsyncWork::DispatchAsyncWork(OHOS::ACELite::ExecuteSendMsgToJS, static_cast(params)); + if (!ret) { + HILOG_ERROR(HILOG_MODULE_ACE, "Failed to dispatch async work"); + OHOS::ACELite::ace_free(params->msgBody); + params->msgBody = nullptr; + delete params; + params = nullptr; + return -1; + } + return 0; +}; +#endif +// OHOS END diff --git a/code/sdk/open_source/openharmony/base/startup/syspara_lite/include/parameter.h b/code/sdk/open_source/openharmony/base/startup/syspara_lite/include/parameter.h index 882081d0a..3b1e74d3a 100644 --- a/code/sdk/open_source/openharmony/base/startup/syspara_lite/include/parameter.h +++ b/code/sdk/open_source/openharmony/base/startup/syspara_lite/include/parameter.h @@ -420,6 +420,15 @@ int GetSdkApiVersion(void); int GetFirstApiVersion(void); const char *GetOsReleaseType(void); const char *GetOSFullName(void); +int GetMajorVersion(void); +int GetSeniorVersion(void); +int GetFeatureVersion(void); +int GetBuildVersion(void); +const char *GetDistributionOSName(void); +const char *GetDistributionOSVersion(void); +int GetDistributionOSApiVersion(void); +const char *GetDistributionOSReleaseType(void); +int GetMacAddress(char *macAddress, int size); #ifdef __cplusplus #if __cplusplus } diff --git a/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/hal_sys_param.c b/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/hal_sys_param.c index e9c6ea886..8761617f3 100644 --- a/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/hal_sys_param.c +++ b/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/hal_sys_param.c @@ -34,7 +34,7 @@ static const char OHOS_HARDWARE_PROFILE[] = {"aout:true,display:true"}; static const char OHOS_BOOTLOADER_VERSION[] = {"bootloader"}; static const char OHOS_SECURITY_PATCH_TAG[] = {"2024/12/01"}; static const char OHOS_ABI_LIST[] = {"riscv-liteos"}; -static const char OHOS_SERIAL[] = {"1234567890"}; // provided by OEM. +static const char OHOS_SERIAL[] = {"****"}; // provided by OEM. const char g_roBuildOs[] = {"OpenHarmony"}; const char g_roBuildVerShow[] = {"OpenHarmony 5.0.1.115"}; const int g_roFirstApiLevel = 1; diff --git a/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/parameter_common.c b/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/parameter_common.c index 6cb6b64f0..820ba1353 100644 --- a/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/parameter_common.c +++ b/code/sdk/open_source/openharmony/base/startup/syspara_lite/src/parameter_common.c @@ -39,6 +39,8 @@ #define DEV_BUF_MAX_LENGTH 1024 #define DEV_UUID_LENGTH 65 #define OS_FULL_NAME_LEN 128 +#define BT_MAC_BUFF_SIZE 6 +#define BT_MAC_BUFF_LEN 17 static char g_roBuildOs[] = {"OpenHarmony-5.0.1.115"}; static char g_roBuildVerShow[] = {"1.0.0"}; @@ -48,6 +50,7 @@ static const char OHOS_OS_NAME[] = { "OpenHarmony" }; static const int OHOS_SDK_API_VERSION = 13; static const char OHOS_SECURITY_PATCH_TAG[] = {"2024/12/01"}; static const char OHOS_RELEASE_TYPE[] = { "Release" }; +static const char OHOS_DEFAULT_VALUE[] = { "Default" }; static const int MAJOR_VERSION = 5; static const int SENIOR_VERSION = 0; @@ -311,6 +314,22 @@ static int GetSha256Value(const unsigned char *input, char *udid, int udidSize) return EC_SUCCESS; } +int GetMacAddress(char *macAddress, int size) +{ + if (size < BT_MAC_BUFF_LEN + 1) { + return EC_FAILURE; + } + memset(macAddress, 0, size); + uint8_t mac[BT_MAC_BUFF_SIZE] = {0}; + uint32_t ret = bluetooth_get_local_addr(mac, BT_MAC_BUFF_SIZE); + if(ret != 0) { + return EC_FAILURE; + } + snprintf(macAddress, size + 1, "%02x:%02x:%02x:%02x:%02x:%02x", + mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); // ¹Ì¶¨6¸ö×Ö½ÚÆ´½Ó + return ret; +} + int GetDevUdid(char *udid, int size) { if (size < DEV_UUID_LENGTH) { @@ -323,7 +342,13 @@ int GetDevUdid(char *udid, int size) if (manufacture == NULL || model == NULL || sn == NULL) { return EC_FAILURE; } - int tmpSize = strlen(manufacture) + strlen(model) + strlen(sn) + 1; + int tmpSize = 0; + if (strcmp(sn, "****") == 0) { + tmpSize = strlen(manufacture) + strlen(model) + BT_MAC_BUFF_LEN + 1; + } else { + tmpSize = strlen(manufacture) + strlen(model) + strlen(sn) + 1; + } + if (tmpSize <= 0 || tmpSize > DEV_BUF_MAX_LENGTH) { return EC_FAILURE; } @@ -334,12 +359,26 @@ int GetDevUdid(char *udid, int size) memset_s(tmp, tmpSize, 0, tmpSize); if ((strcat_s(tmp, tmpSize, manufacture) != 0) || - (strcat_s(tmp, tmpSize, model) != 0) || - (strcat_s(tmp, tmpSize, sn) != 0)) { + (strcat_s(tmp, tmpSize, model) != 0)) { free(tmp); return EC_FAILURE; } - + if (strcmp(sn, "****") == 0) { + uint8_t mac[BT_MAC_BUFF_SIZE] = {0}; + uint32_t ret = bluetooth_get_local_addr(mac, BT_MAC_BUFF_SIZE); + char mac_str[BT_MAC_BUFF_LEN + 1] = {0}; // 17×Ö½Ú + ÖÕÖ¹·û + snprintf(mac_str, sizeof(mac_str), "%02x:%02x:%02x:%02x:%02x:%02x", + mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); // ¹Ì¶¨6¸ö×Ö½ÚÆ´½Ó + if ((strcat_s(tmp, tmpSize, mac_str) != 0)) { + free(tmp); + return EC_FAILURE; + } + } else { + if ((strcat_s(tmp, tmpSize, sn) != 0)) { + free(tmp); + return EC_FAILURE; + } + } int ret = GetSha256Value(tmp, udid, size); free(tmp); return ret; @@ -410,3 +449,43 @@ const char *GetOSFullName(void) } return osFullName; } + +int GetMajorVersion(void) +{ + return MAJOR_VERSION; +} + +int GetSeniorVersion(void) +{ + return SENIOR_VERSION; +} + +int GetFeatureVersion(void) +{ + return FEATURE_VERSION; +} + +int GetBuildVersion(void) +{ + return BUILD_VERSION; +} + +const char *GetDistributionOSName(void) +{ + return OHOS_DEFAULT_VALUE; +} + +const char *GetDistributionOSVersion(void) +{ + return OHOS_DEFAULT_VALUE; +} + +int GetDistributionOSApiVersion(void) +{ + return 0; +} + +const char *GetDistributionOSReleaseType(void) +{ + return OHOS_DEFAULT_VALUE; +} \ No newline at end of file