1 /*
2 * Copyright (C) 2022 Huawei Technologies Co., Ltd.
3 * Licensed under the Mulan PSL v2.
4 * You can use this software according to the terms and conditions of the Mulan PSL v2.
5 * You may obtain a copy of Mulan PSL v2 at:
6 * http://license.coscl.org.cn/MulanPSL2
7 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
8 * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
9 * PURPOSE.
10 * See the Mulan PSL v2 for more details.
11 */
12 #include <pthread.h>
13 #include <mem_ops.h>
14 #include "tee_defines.h"
15 #include "ta_framework.h"
16 #include "tee_log.h"
17 #include "securec.h"
18 #include "ipclib.h"
19 #include "permsrv_api_imp.h"
20 #include "tee_internal_task_pub.h"
21 #include "tee_inner_uuid.h"
22
23 #define PERM_PATH "permservice"
24 static uint32_t g_init_state = INIT_STATE_NOT_READY;
25 static pthread_mutex_t g_msg_call_mutex = PTHREAD_MUTEX_INITIALIZER;
26 static TEE_UUID g_permsrv_uuid = TEE_SERVICE_PERM;
27
perm_srv_msg_call(const char * path,perm_srv_req_msg_t * msg,perm_srv_reply_msg_t * rsp)28 int perm_srv_msg_call(const char *path, perm_srv_req_msg_t *msg, perm_srv_reply_msg_t *rsp)
29 {
30 errno_t rc;
31 cref_t rslot = 0;
32
33 if (path == NULL || msg == NULL) {
34 tloge("path or msg is null\n");
35 return -1;
36 }
37
38 if (pthread_mutex_lock(&g_msg_call_mutex) != 0) {
39 tloge("perm msg call mutex lock failed\n");
40 return -1;
41 }
42 rc = ipc_get_ch_from_path(path, &rslot);
43 if (rc == -1) {
44 tloge("permsrv: get channel from pathmgr failed\n");
45 (void)pthread_mutex_unlock(&g_msg_call_mutex);
46 return rc;
47 }
48
49 if (rsp == NULL)
50 rc = ipc_msg_notification(rslot, msg, sizeof(*msg));
51 else
52 rc = ipc_msg_call(rslot, msg, sizeof(*msg), rsp, sizeof(*rsp), -1);
53 if (rc < 0)
54 tloge("msg send 0x%llx failed: 0x%x\n", rslot, rc);
55
56 (void)ipc_release_from_path(path, rslot);
57 (void)pthread_mutex_unlock(&g_msg_call_mutex);
58 return rc;
59 }
60
tee_perm_init_msg(perm_srv_req_msg_t * req_msg,perm_srv_reply_msg_t * reply_msg)61 void tee_perm_init_msg(perm_srv_req_msg_t *req_msg, perm_srv_reply_msg_t *reply_msg)
62 {
63 if (req_msg != NULL)
64 (void)memset_s(req_msg, sizeof(*req_msg), 0, sizeof(*req_msg));
65
66 if (reply_msg != NULL)
67 (void)memset_s(reply_msg, sizeof(*reply_msg), 0, sizeof(*reply_msg));
68 }
69
permsrv_registerta(const TEE_UUID * uuid,uint32_t task_id,uint32_t user_id,uint32_t opt_type)70 void permsrv_registerta(const TEE_UUID *uuid, uint32_t task_id, uint32_t user_id, uint32_t opt_type)
71 {
72 perm_srv_req_msg_t req_msg;
73
74 tee_perm_init_msg(&req_msg, NULL);
75 if (uuid == NULL) {
76 tloge("register TA with NULL uuid\n");
77 return;
78 }
79
80 if (opt_type == REGISTER_TA) {
81 req_msg.header.send.msg_id = TEE_TASK_OPEN_TA_SESSION;
82 } else if (opt_type == UNREGISTER_TA) {
83 req_msg.header.send.msg_id = TEE_TASK_CLOSE_TA_SESSION;
84 } else {
85 tloge("perm srv not support operation type!\n");
86 return;
87 }
88
89 req_msg.req_msg.reg_ta.uuid = *uuid;
90 req_msg.req_msg.reg_ta.taskid = task_id;
91 req_msg.req_msg.reg_ta.userid = user_id;
92
93 if (perm_srv_msg_call(PERM_PATH, &req_msg, NULL) < 0)
94 tloge("register ta msg send failed!\n");
95 }
96
permsrv_notify_unload_ta(const TEE_UUID * uuid)97 void permsrv_notify_unload_ta(const TEE_UUID *uuid)
98 {
99 perm_srv_req_msg_t req_msg;
100
101 tee_perm_init_msg(&req_msg, NULL);
102 if (uuid == NULL) {
103 tloge("uuid is NULL\n");
104 return;
105 }
106
107 req_msg.header.send.msg_id = TEE_TASK_RELEASE_TA_SERVICE;
108 req_msg.req_msg.ta_unload.uuid = *uuid;
109
110 if (perm_srv_msg_call(PERM_PATH, &req_msg, NULL) < 0)
111 tloge("ta unload msg send failed!\n");
112 }
113
rslot_file_msg_call(perm_srv_req_msg_t * req_msg,perm_srv_reply_msg_t * reply_msg)114 TEE_Result rslot_file_msg_call(perm_srv_req_msg_t *req_msg, perm_srv_reply_msg_t *reply_msg)
115 {
116 if (req_msg == NULL || reply_msg == NULL) {
117 tloge("req_msg or reply_msg is null!\n");
118 return TEE_ERROR_GENERIC;
119 }
120
121 if (perm_srv_msg_call(PERMSRV_FILE_OPT, req_msg, reply_msg) < 0) {
122 tloge("msg send failed!\n");
123 return TEE_ERROR_GENERIC;
124 }
125
126 tlogd("msg call ret is 0x%x\n", reply_msg->reply.ret);
127 return reply_msg->reply.ret;
128 }
129
tee_crl_cert_process(const char * crl_cert,uint32_t crl_cert_size)130 TEE_Result tee_crl_cert_process(const char *crl_cert, uint32_t crl_cert_size)
131 {
132 perm_srv_req_msg_t req_msg;
133 perm_srv_reply_msg_t reply_msg;
134
135 uint8_t *crl_shared = NULL;
136 uint32_t crl_size;
137
138 tee_perm_init_msg(&req_msg, &reply_msg);
139 errno_t rc;
140 TEE_Result ret = TEE_ERROR_GENERIC;
141
142 if (crl_cert == NULL) {
143 tloge("bad parameter for points\n");
144 return TEE_ERROR_BAD_PARAMETERS;
145 }
146 if (crl_cert_size == 0 || crl_cert_size > MAX_PERM_SRV_BUFF_SIZE) {
147 tloge("bad parameter for size!\n");
148 return TEE_ERROR_BAD_PARAMETERS;
149 }
150
151 crl_size = crl_cert_size;
152 crl_shared = alloc_sharemem_aux(&g_permsrv_uuid, crl_size);
153 if (crl_shared == NULL) {
154 tloge("malloc sharedBuff failed, size=0x%x\n", crl_size);
155 return TEE_ERROR_OUT_OF_MEMORY;
156 }
157 rc = memmove_s(crl_shared, crl_size, crl_cert, crl_cert_size);
158 if (rc != EOK) {
159 tloge("copy the conf error, rc = 0x%x", rc);
160 ret = TEE_ERROR_SECURITY;
161 goto clean;
162 }
163
164 req_msg.header.send.msg_id = PERMSRV_SET_CRL_CERT;
165 req_msg.req_msg.crl_cert.crl_cert_buff = (uintptr_t)crl_shared;
166 req_msg.req_msg.crl_cert.crl_cert_size = crl_size;
167 reply_msg.reply.ret = TEE_ERROR_GENERIC;
168
169 ret = rslot_file_msg_call(&req_msg, &reply_msg);
170
171 clean:
172 if (crl_shared != NULL)
173 (void)free_sharemem(crl_shared, crl_size);
174 return ret;
175 }
176
permsrv_load_file(void)177 void permsrv_load_file(void)
178 {
179 perm_srv_req_msg_t req_msg;
180
181 tee_perm_init_msg(&req_msg, NULL);
182 req_msg.header.send.msg_id = TEE_TASK_LOAD_CRL_AND_CTRL_LIST;
183
184 if (g_init_state == INIT_STATE_READY)
185 return;
186
187 if (perm_srv_msg_call(PERMSRV_FILE_OPT, &req_msg, NULL) < 0) {
188 tloge("register ta msg failed!\n");
189 return;
190 }
191
192 g_init_state = INIT_STATE_READY;
193 }
194
permsrv_elf_verify(const void * verify_req,uint32_t len)195 TEE_Result permsrv_elf_verify(const void *verify_req, uint32_t len)
196 {
197 errno_t rc;
198 perm_srv_req_msg_t req_msg;
199
200 if (verify_req == NULL) {
201 tloge("elf verify req is null\n");
202 return TEE_ERROR_BAD_PARAMETERS;
203 }
204
205 if (len != sizeof(req_msg.req_msg.verify_req)) {
206 tloge("elf verify req len %u is invalid\n", len);
207 return TEE_ERROR_BAD_PARAMETERS;
208 }
209
210 tee_perm_init_msg(&req_msg, NULL);
211 req_msg.header.send.msg_id = TEE_TASK_ELF_VERIFY;
212 req_msg.header.send.msg_size = len;
213
214 rc = memcpy_s(&(req_msg.req_msg.verify_req), sizeof(req_msg.req_msg.verify_req), verify_req, len);
215 if (rc != EOK) {
216 tloge("copy verify req msg failed: 0x%x\n", rc);
217 return TEE_ERROR_GENERIC;
218 }
219
220 if (perm_srv_msg_call(PERMSRV_ASYNC_OPT, &req_msg, NULL) < 0) {
221 tloge("elf verify msg failed!\n");
222 return TEE_ERROR_GENERIC;
223 }
224
225 return TEE_SUCCESS;
226 }
227