mbtk/libgsw_lib/gsw_secrypt_ss_interface.c

#include <dlfcn.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "gsw_secrypt_ss_interface.h"
#include "gsw_hal_errcode.h"
#include "gsw_log_interface.h"

#define GSW_TEE "[HAL][GSW_TEE]"

/**
 * struct TEEC_Context - Represents a connection between a client application
 * and a TEE.
 */
 typedef struct {
	/* Implementation defined */
	struct {
		int fd;
		bool reg_mem;
		bool memref_null;
	} imp;
} TEEC_Context;

/**
 * struct TEEC_Session - Represents a connection between a client application
 * and a trusted application.
 */
 typedef struct {
	/* Implementation defined */
	struct {
		TEEC_Context *ctx;
		uint32_t session_id;
	} imp;
} TEEC_Session;

struct test_ctx {
    TEEC_Context ctx;
    TEEC_Session sess;
};

#define TEEC_SUCCESS                       0x00000000
#define TEEC_ERROR_STORAGE_NOT_AVAILABLE   0xF0100003
#define TEEC_ERROR_GENERIC                 0xFFFF0000
#define TEEC_ERROR_ACCESS_DENIED           0xFFFF0001
#define TEEC_ERROR_CANCEL                  0xFFFF0002
#define TEEC_ERROR_ACCESS_CONFLICT         0xFFFF0003
#define TEEC_ERROR_EXCESS_DATA             0xFFFF0004
#define TEEC_ERROR_BAD_FORMAT              0xFFFF0005
#define TEEC_ERROR_BAD_PARAMETERS          0xFFFF0006
#define TEEC_ERROR_BAD_STATE               0xFFFF0007
#define TEEC_ERROR_ITEM_NOT_FOUND          0xFFFF0008
#define TEEC_ERROR_NOT_IMPLEMENTED         0xFFFF0009
#define TEEC_ERROR_NOT_SUPPORTED           0xFFFF000A
#define TEEC_ERROR_NO_DATA                 0xFFFF000B
#define TEEC_ERROR_OUT_OF_MEMORY           0xFFFF000C
#define TEEC_ERROR_BUSY                    0xFFFF000D
#define TEEC_ERROR_COMMUNICATION           0xFFFF000E
#define TEEC_ERROR_SECURITY                0xFFFF000F
#define TEEC_ERROR_SHORT_BUFFER            0xFFFF0010
#define TEEC_ERROR_EXTERNAL_CANCEL         0xFFFF0011
#define TEEC_ERROR_TARGET_DEAD             0xFFFF3024

struct test_ctx ctx;

#define lib_secure_path "/lib/libsecure_storage.so"
static void *dlHandle_secure;

#define lib_mbtk_path "/lib/libmbtk_lib.so"
static void *dlHandle_mbtk;
#define PUBLIC_KEY_SEC_NAME "public_key_obj"
#define SEC_LEVEL1_SEC_NAME "sec_level1_obj"
typedef struct
{
    size_t length;
    int is_update;
    //int is_read;
    unsigned char *content;
} tmp_sec;
tmp_sec public_key_sec = {0};
tmp_sec sec_level1_sec = {0};

typedef uint32_t TEEC_Result;
// static void (*mbtk_log)(int level, const char *format, ...);
// static void (*mbtk_log_init)(char *path, char *tag);

int (*prepare_tee_session)(struct test_ctx *ctx);
void (*terminate_tee_session)(struct test_ctx *ctx);
TEEC_Result (*read_secure_object)(struct test_ctx *ctx, const char *id,char *data, size_t *data_len);
TEEC_Result (*write_secure_object)(struct test_ctx *ctx, const char *id,char *data, size_t data_len);
TEEC_Result (*delete_secure_object)(struct test_ctx *ctx, const char *id);

static int tee_api_import(void)
{

    dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
    if (dlHandle_mbtk == NULL) 
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    dlHandle_secure = dlopen(lib_secure_path, RTLD_NOW);
    if (dlHandle_secure == NULL) 
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    // mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
    // if (mbtk_log_init == NULL) 
    // {
    //     return GSW_HAL_NORMAL_FAIL;
    // }

    // mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
    // if (mbtk_log == NULL) 
    // {
    //     return GSW_HAL_NORMAL_FAIL;
    // }

    prepare_tee_session = (int (*)(struct test_ctx *ctx))dlsym(dlHandle_secure, "prepare_tee_session");
    if (prepare_tee_session == NULL) 
    {
        LOGE(GSW_TEE,"prepare_tee_session dlsym fail\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    terminate_tee_session = (void (*)(struct test_ctx *ctx))dlsym(dlHandle_secure, "terminate_tee_session");
    if (terminate_tee_session == NULL) 
    {
        LOGE(GSW_TEE,"terminate_tee_session dlsym fail\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    read_secure_object = (TEEC_Result (*)(struct test_ctx *ctx, const char *id,char *data, size_t *data_len))dlsym(dlHandle_secure, "read_secure_object");
    if (read_secure_object == NULL) 
    {
        LOGE(GSW_TEE,"read_secure_object dlsym fail\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    write_secure_object = (TEEC_Result (*)(struct test_ctx *ctx, const char *id,char *data, size_t data_len))dlsym(dlHandle_secure, "write_secure_object");
    if (write_secure_object == NULL) 
    {
        LOGE(GSW_TEE,"write_secure_object dlsym fail\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    delete_secure_object = (TEEC_Result (*)(struct test_ctx *ctx, const char *id))dlsym(dlHandle_secure, "delete_secure_object");
    if (delete_secure_object == NULL) 
    {
        LOGE(GSW_TEE,"delete_secure_object dlsym fail\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    return GSW_HAL_SUCCESS;
}

/**
* @brief init tee sdk
* @param  [in] None
* @param  [out] None
* @retval GSW_HAL_SUCCESS is success\other is fail
*/
int32_t gsw_tee_sdk_init(void)
{
    LOGE(GSW_TEE,"init start\n");
    int32_t ret = 0;
    ret = tee_api_import();
    if(ret)
    {
	LOGE(GSW_TEE,"tee_api_import fail\n");
        return ret;
    }
    ret = prepare_tee_session(&ctx);
    LOGE(GSW_TEE,"init end\n");
    if (public_key_sec.content == NULL) {
        public_key_sec.content = malloc(7000);
        public_key_sec.length = 0;
        public_key_sec.is_update = 0;
    }
    
    if (sec_level1_sec.content == NULL) {
        sec_level1_sec.content = malloc(7000);
        sec_level1_sec.length = 0;
        sec_level1_sec.is_update = 0;
    }
    return ret;
}

/**
* @brief read sensitive data from tee
* @param  [in] char* in_obj_name :Sensitive data name
* @param  [in] unsigned int* p_out_buf_len：The size of sensitive data output cache
* @param  [out] char* out_buf：Cache of sensitive data output
* @param  [out] unsigned int* p_out_buf_len：Sensitive data length
* @retval GSW_HAL_SUCCESS is success\other is fail
*/
#define basic_buf_len  7000
int32_t gsw_tee_read_secure_data(const char* in_obj_name, char* out_buf, unsigned int* p_out_buf_len)
{
    //LOGE(GSW_TEE,"start read\n");
    if (in_obj_name == NULL || out_buf == NULL)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    
    int32_t ret = 0;
    size_t size = basic_buf_len;
    char *tmp_buf = (char*)malloc(basic_buf_len);
    if (NULL == tmp_buf)
    {
        LOGE(GSW_TEE,"Failed malloc fail");
        return GSW_HAL_NO_MEMORY;
    }

    bool is_pubkey = !strncmp(in_obj_name, PUBLIC_KEY_SEC_NAME, strlen(PUBLIC_KEY_SEC_NAME));
    bool is_level1 = !strncmp(in_obj_name, SEC_LEVEL1_SEC_NAME, strlen(SEC_LEVEL1_SEC_NAME));

    if (is_pubkey || is_level1)
    {
        tmp_sec *target = is_pubkey ? &public_key_sec : &sec_level1_sec;
        if (target->is_update)
        {
            if (target->length == 0 || target->content[0] == '\0')
                ret = GSW_HAL_ERROR_TEE_SFS_FILE_NOEXIST;
            else
            {
                memcpy(out_buf, target->content, target->length);
                *p_out_buf_len = target->length;
                ret = GSW_HAL_SUCCESS;
            }
            free(tmp_buf);
            return ret;
        }
        

        TEEC_Result res = read_secure_object(&ctx, in_obj_name, tmp_buf, &size);
        
        if (res == TEEC_ERROR_ITEM_NOT_FOUND)
        {
            LOGE(GSW_TEE, "the obj no found\n");
            ret = GSW_HAL_ERROR_TEE_SFS_FILE_NOEXIST;

            target->is_update = 1; 
            target->length = 0;
            target->content[0] = '\0';
        }
        else if (res == TEEC_SUCCESS)
        {
            LOGE(GSW_TEE, "the obj is exist\n");
            memcpy(target->content, tmp_buf, size);

            target->length = size;
            target->is_update = 1;
            
            memcpy(out_buf, tmp_buf, size);
            *p_out_buf_len = size;
            
            ret = GSW_HAL_SUCCESS;
        }
        else
        {
            LOGE(GSW_TEE,"Failed to read an object from the secure storage");
            ret = GSW_HAL_NORMAL_FAIL;
        }
        
        free(tmp_buf);
        return ret;
    }

    TEEC_Result res = read_secure_object(&ctx, in_obj_name, tmp_buf, &size);
    if (res == TEEC_ERROR_ITEM_NOT_FOUND)
    {
        LOGE(GSW_TEE,"the obj no found\n");
        ret = GSW_HAL_ERROR_TEE_SFS_FILE_NOEXIST;
    }
    else if (res == TEEC_SUCCESS)
    {
        LOGE(GSW_TEE,"the obj is exist\n");
        memcpy(out_buf, tmp_buf, size);
        *p_out_buf_len = size;
        ret = GSW_HAL_SUCCESS;
    }
    else
    {
        LOGE(GSW_TEE,"Failed to read an object from the secure storage");
        ret = GSW_HAL_NORMAL_FAIL;
    }

    free(tmp_buf);
    return ret; 
}

/**
* @brief write sensitive data to tee
* @param  [in] char* in_obj_name :Sensitive data name
* @param  [in] char* in_buf：A cache for writing sensitive data
* @param  [out] unsigned int in_buf_len：Sensitive data length
* @retval GSW_HAL_SUCCESS is success\other is fail
*/
int32_t gsw_tee_write_secure_data(const char* in_obj_name, char* in_buf, unsigned int in_buf_len)
{
    LOGE(GSW_TEE,"write start\n");
    if (in_obj_name == NULL || in_buf == NULL)
        return GSW_HAL_NORMAL_FAIL;
    int32_t ret = 0;

    TEEC_Result res = write_secure_object(&ctx, in_obj_name,in_buf, in_buf_len);
    if (res != TEEC_SUCCESS)
    {
	LOGE(GSW_TEE,"Failed to write an object from the secure storage");
        ret = GSW_HAL_NORMAL_FAIL;
    }
    bool is_pubkey = !strncmp(in_obj_name, PUBLIC_KEY_SEC_NAME, strlen(PUBLIC_KEY_SEC_NAME));
    bool is_level1 = !strncmp(in_obj_name, SEC_LEVEL1_SEC_NAME, strlen(SEC_LEVEL1_SEC_NAME));
    if (is_pubkey || is_level1)
    {
        tmp_sec *target = is_pubkey ? &public_key_sec : &sec_level1_sec;
        target->is_update = 0;
    }
    LOGE(GSW_TEE,"write really end\n");
    return ret;
}


/**
* @brief delete sensitive data from tee
* @param  [in] char* in_obj_name :Sensitive data name
* @retval GSW_HAL_SUCCESS is success\other is fail
*/
int32_t gsw_tee_delete_secure_data(const char* in_obj_name)
{
    LOGE(GSW_TEE,"delete start\n");
    if (in_obj_name == NULL)
        return GSW_HAL_NORMAL_FAIL;
    int32_t ret = 0;

    TEEC_Result res = delete_secure_object(&ctx, in_obj_name);
    if (res != TEEC_SUCCESS)
    {
	LOGE(GSW_TEE,"Failed to delete the object: 0x%x", res);
        ret = GSW_HAL_NORMAL_FAIL;
    }
    bool is_pubkey = !strncmp(in_obj_name, PUBLIC_KEY_SEC_NAME, strlen(PUBLIC_KEY_SEC_NAME));
    bool is_level1 = !strncmp(in_obj_name, SEC_LEVEL1_SEC_NAME, strlen(SEC_LEVEL1_SEC_NAME));
    if (is_pubkey || is_level1)
    {
        tmp_sec *target = is_pubkey ? &public_key_sec : &sec_level1_sec;
        target->length = 0;
    }
    LOGE(GSW_TEE,"delete really end\n");
    return ret;
}

/**
* @brief check sensitive data from tee
* @param  [in] char* in_obj_name :Sensitive data name
* @retval GSW_HAL_SUCCESS is exist\ other is not exist or fail
*/
int32_t gsw_tee_check_secure_data(const char* in_obj_name)
{
    if (in_obj_name == NULL)
        return GSW_HAL_NORMAL_FAIL;
    int32_t ret = 1;
    size_t size = basic_buf_len;
    char *tmp_buf = (char*)malloc(basic_buf_len);
    if (NULL == tmp_buf)
    {
        LOGE(GSW_TEE,"Failed malloc fail");
        return GSW_HAL_NO_MEMORY;
    }
    TEEC_Result res = read_secure_object(&ctx, in_obj_name, tmp_buf, &size);
    if (res == TEEC_ERROR_ITEM_NOT_FOUND)
    {
        LOGE(GSW_TEE,"the obj no found\n");
        ret = GSW_HAL_ERROR_TEE_SFS_FILE_NOEXIST;
    }
    else if (res == TEEC_SUCCESS)
    {
        LOGE(GSW_TEE,"the obj is exist\n");
        ret = GSW_HAL_SUCCESS;
    }
    else
    {
        LOGE(GSW_TEE,"Failed to read an object from the secure storage");
        ret = GSW_HAL_NORMAL_FAIL;
    }
    free(tmp_buf);
    return ret;
}

/**
* @brief deinit tee sdk
* @param [in] None
* @param [out] None
* @retval GSW_HAL_SUCCESS is success\other is fail
*/
int32_t gsw_tee_sdk_deinit(void)
{
    LOGE(GSW_TEE,"deinit start\n");
    if (terminate_tee_session) {
        terminate_tee_session(&ctx);  // 终止TEE会话
        terminate_tee_session = NULL;
    }

    if (dlHandle_secure) {
        dlclose(dlHandle_secure);  // 卸载安全库
        dlHandle_secure = NULL;
    }

    if (dlHandle_mbtk) {
        dlclose(dlHandle_mbtk);  // 卸载日志库
        dlHandle_mbtk = NULL;
    }
    LOGE(GSW_TEE,"deinit end\n");
    return GSW_HAL_SUCCESS;
}

int32_t gsw_secure_init(void)
{
    static int s_init_flag = 0;
    if (0xAA55 == s_init_flag)
    {
        return GSW_HAL_SUCCESS;
    }
    if (GSW_HAL_SUCCESS == gsw_tee_sdk_init())
    {
        s_init_flag = 0xAA55;
        return GSW_HAL_SUCCESS;
    }
    LOGE(GSW_TEE,"secure sdk init fail!!!");
    return GSW_HAL_NORMAL_FAIL;
}

int32_t gsw_secure_storage_query(const char *objname, int32_t *exist_state)
{
#if 0
    if (NULL == objname || NULL == exist_state)
    {
        LOGE(GSW_TEE,"storage query input param error objname %p, exist_state %p",objname, exist_state);
        return GSW_HAL_ARG_INVALID;
    }
    int32_t ret = gsw_secure_init();
    if (GSW_HAL_SUCCESS != ret)
    {
        return ret;
    }
    ret = gsw_tee_check_secure_data(objname);
    if (GSW_HAL_SUCCESS == ret)
    {
        *exist_state = 1; //表明数据存在
    }
    else
    {
        *exist_state = 0;
    }
    return ret;
#else
    return GSW_HAL_NO_SUPPROT;
#endif
}

int32_t gsw_secure_storage_read(const char *objname, uint8_t *outbuf, uint32_t buflen, uint32_t *outlen)
{
#if 0
    if (NULL == objname || NULL == outbuf || NULL == outlen)
    {
        LOGE(GSW_TEE,"storage read input param error objname %p, outbuf %p, outlen %p",objname, outbuf, outlen);
        return GSW_HAL_ARG_INVALID;
    }
    int32_t ret = gsw_secure_init();
    if (GSW_HAL_SUCCESS != ret)
    {
        return ret;
    }
    *outlen = buflen;
    return gsw_tee_read_secure_data(objname, (char*)outbuf, outlen);
#else
    return GSW_HAL_NO_SUPPROT;
#endif

}

int32_t gsw_secure_storage_write(const char *objname, const uint8_t *inbuf, uint32_t inlen)
{
#if 0
    if (NULL == objname || NULL == inbuf || 0 == inlen)
    {
        LOGE(GSW_TEE,"storage write input param error objname %p, outbuf %p, inlen %u",objname, inbuf, inlen);
        return GSW_HAL_ARG_INVALID;
    }
    int32_t ret = gsw_secure_init();
    if (GSW_HAL_SUCCESS != ret)
    {
        return ret;
    }
    return gsw_tee_write_secure_data(objname, (char*)inbuf, inlen);
#else
    return GSW_HAL_NO_SUPPROT;
#endif
}

int32_t gsw_secure_storage_delete(const char *objname)
{
#if 0
    if (NULL == objname)
    {
        LOGE(GSW_TEE,"storage delete input param error objname %p",objname);
        return GSW_HAL_ARG_INVALID;
    }
    int32_t ret = gsw_secure_init();
    if (GSW_HAL_SUCCESS != ret)
    {
        return ret;
    }
    return gsw_tee_delete_secure_data(objname);
#else
    return GSW_HAL_NO_SUPPROT;
#endif
}