1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "nativetoken.h"
16 
17 #ifdef WITH_SELINUX
18 #include <policycoreutils.h>
19 #endif // WITH_SELINUX
20 
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28 #include "securec.h"
29 #include "nativetoken_json_oper.h"
30 #include "nativetoken_kit.h"
31 #include "nativetoken_klog.h"
32 
33 
34 NativeTokenList *g_tokenListHead;
35 int32_t g_isNativeTokenInited = 0;
36 
GetFileBuff(const char * cfg,char ** retBuff)37 int32_t GetFileBuff(const char *cfg, char **retBuff)
38 {
39     struct stat fileStat;
40 
41     char filePath[PATH_MAX_LEN + 1] = {0};
42     if (realpath(cfg, filePath) == NULL) {
43         if (errno == ENOENT) {
44             /* file doesn't exist */
45             *retBuff = NULL;
46             return ATRET_SUCCESS;
47         }
48         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:invalid filePath.", __func__);
49         return ATRET_FAILED;
50     }
51 
52     if (stat(filePath, &fileStat) != 0) {
53         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:stat file failed.", __func__);
54         return ATRET_FAILED;
55     }
56 
57     if (fileStat.st_size == 0) {
58         *retBuff = NULL;
59         return ATRET_SUCCESS;
60     }
61 
62     if (fileStat.st_size > MAX_JSON_FILE_LEN) {
63         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:stat file size is invalid.", __func__);
64         return ATRET_FAILED;
65     }
66 
67     size_t fileSize = (unsigned)fileStat.st_size;
68 
69     FILE *cfgFd = fopen(filePath, "r");
70     if (cfgFd == NULL) {
71         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:fopen file failed.", __func__);
72         return ATRET_FAILED;
73     }
74 
75     char *buff = (char *)malloc((size_t)(fileSize + 1));
76     if (buff == NULL) {
77         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:memory alloc failed.", __func__);
78         (void)fclose(cfgFd);
79         return ATRET_FAILED;
80     }
81 
82     if (fread(buff, fileSize, 1, cfgFd) != 1) {
83         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:fread failed.", __func__);
84         free(buff);
85         buff = NULL;
86         (void)fclose(cfgFd);
87         return ATRET_FAILED;
88     }
89     buff[fileSize] = '\0';
90     *retBuff = buff;
91     (void)fclose(cfgFd);
92     return ATRET_SUCCESS;
93 }
94 
StrAttrSet(StrArrayAttr * attr,uint32_t maxStrLen,int32_t maxStrNum,const char * strKey)95 static void StrAttrSet(StrArrayAttr *attr, uint32_t maxStrLen, int32_t maxStrNum, const char *strKey)
96 {
97     attr->maxStrLen = maxStrLen;
98     attr->maxStrNum = maxStrNum;
99     attr->strKey = strKey;
100 }
101 
GetNativeTokenFromJson(cJSON * cjsonItem,NativeTokenList * tokenNode)102 static int32_t GetNativeTokenFromJson(cJSON *cjsonItem, NativeTokenList *tokenNode)
103 {
104     uint32_t ret;
105     StrArrayAttr attr;
106 
107     ret = GetProcessNameFromJson(cjsonItem, tokenNode);
108     ret |= GetTokenIdFromJson(cjsonItem, tokenNode);
109     ret |= GetAplFromJson(cjsonItem, tokenNode);
110 
111     StrAttrSet(&attr, MAX_DCAP_LEN, MAX_DCAPS_NUM, DCAPS_KEY_NAME);
112     ret |= GetInfoArrFromJson(cjsonItem, tokenNode->dcaps, &(tokenNode->dcapsNum), &attr);
113     if (ret != ATRET_SUCCESS) {
114         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:GetInfoArrFromJson failed for dcaps.", __func__);
115         return ATRET_FAILED;
116     }
117 
118     StrAttrSet(&attr, MAX_PERM_LEN, MAX_PERM_NUM, PERMS_KEY_NAME);
119     ret = GetInfoArrFromJson(cjsonItem, tokenNode->perms, &(tokenNode->permsNum), &attr);
120     if (ret != ATRET_SUCCESS) {
121         FreeStrArray(tokenNode->dcaps, tokenNode->dcapsNum - 1);
122         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:GetInfoArrFromJson failed for perms.", __func__);
123         return ATRET_FAILED;
124     }
125 
126     StrAttrSet(&attr, MAX_PERM_LEN, MAX_PERM_NUM, ACLS_KEY_NAME);
127     ret = GetInfoArrFromJson(cjsonItem, tokenNode->acls, &(tokenNode->aclsNum), &attr);
128     if (ret != ATRET_SUCCESS) {
129         FreeStrArray(tokenNode->dcaps, tokenNode->dcapsNum - 1);
130         FreeStrArray(tokenNode->perms, tokenNode->permsNum - 1);
131         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:GetInfoArrFromJson failed for acls.", __func__);
132         return ATRET_FAILED;
133     }
134     return ATRET_SUCCESS;
135 }
136 
GetTokenList(const cJSON * object)137 static int32_t GetTokenList(const cJSON *object)
138 {
139     NativeTokenList *tmp = NULL;
140 
141     if (object == NULL) {
142         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:object is null.", __func__);
143         return ATRET_FAILED;
144     }
145     int32_t arraySize = cJSON_GetArraySize(object);
146 
147     for (int32_t i = 0; i < arraySize; i++) {
148         tmp = (NativeTokenList *)malloc(sizeof(NativeTokenList));
149         if (tmp == NULL) {
150             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:memory alloc failed.", __func__);
151             return ATRET_FAILED;
152         }
153         cJSON *cjsonItem = cJSON_GetArrayItem(object, i);
154         if (cjsonItem == NULL) {
155             free(tmp);
156             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:cJSON_GetArrayItem failed.", __func__);
157             return ATRET_FAILED;
158         }
159         if (GetNativeTokenFromJson(cjsonItem, tmp) != ATRET_SUCCESS) {
160             free(tmp);
161             return ATRET_FAILED;
162         }
163 
164         tmp->next = g_tokenListHead->next;
165         g_tokenListHead->next = tmp;
166     }
167     return ATRET_SUCCESS;
168 }
169 
ParseTokenInfo(void)170 static int32_t ParseTokenInfo(void)
171 {
172     char *fileBuff = NULL;
173     cJSON *record = NULL;
174     int32_t ret;
175 
176     ret = GetFileBuff(TOKEN_ID_CFG_FILE_PATH, &fileBuff);
177     if (ret != ATRET_SUCCESS) {
178         return ret;
179     }
180     if (fileBuff == NULL) {
181         return ATRET_SUCCESS;
182     }
183     record = cJSON_Parse(fileBuff);
184     free(fileBuff);
185     fileBuff = NULL;
186 
187     ret = GetTokenList(record);
188     cJSON_Delete(record);
189 
190     return ret;
191 }
192 
CreateCfgFile(void)193 static int32_t CreateCfgFile(void)
194 {
195     int32_t fd = open(TOKEN_ID_CFG_FILE_PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP);
196     if (fd < 0) {
197         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:open failed.", __func__);
198         return ATRET_FAILED;
199     }
200 
201 #ifdef WITH_SELINUX
202     Restorecon(TOKEN_ID_CFG_FILE_PATH);
203 #endif // WITH_SELINUX
204 
205     close(fd);
206     fd = -1;
207 
208     struct stat buf;
209     if (stat(TOKEN_ID_CFG_DIR_PATH, &buf) != 0) {
210         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:stat folder path is invalid %d.", __func__, errno);
211         return ATRET_FAILED;
212     }
213     if (chown(TOKEN_ID_CFG_FILE_PATH, buf.st_uid, buf.st_gid) != 0) {
214         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:chown failed, errno is %d.", __func__, errno);
215         return ATRET_FAILED;
216     }
217 
218     return ATRET_SUCCESS;
219 }
220 
AtlibInit(void)221 int32_t AtlibInit(void)
222 {
223     g_tokenListHead = (NativeTokenList *)malloc(sizeof(NativeTokenList));
224     if (g_tokenListHead == NULL) {
225         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:g_tokenListHead memory alloc failed.", __func__);
226         return ATRET_FAILED;
227     }
228     g_tokenListHead->next = NULL;
229 
230     int32_t ret = ParseTokenInfo();
231     if (ret != ATRET_SUCCESS) {
232         free(g_tokenListHead);
233         g_tokenListHead = NULL;
234         return ret;
235     }
236 
237     if (g_tokenListHead->next == NULL) {
238         if (CreateCfgFile() != ATRET_SUCCESS) {
239             free(g_tokenListHead);
240             g_tokenListHead = NULL;
241             return ATRET_FAILED;
242         }
243     }
244     g_isNativeTokenInited = 1;
245 
246     return ATRET_SUCCESS;
247 }
248 
GetRandomTokenId(uint32_t * randNum)249 static int32_t GetRandomTokenId(uint32_t *randNum)
250 {
251     uint32_t random;
252     ssize_t len;
253     int32_t fd = open("/dev/urandom", O_RDONLY);
254     if (fd < 0) {
255         return ATRET_FAILED;
256     }
257     len = read(fd, &random, sizeof(random));
258     (void)close(fd);
259 
260     if (len != sizeof(random)) {
261         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:read failed.", __func__);
262         return ATRET_FAILED;
263     }
264     *randNum = random;
265     return ATRET_SUCCESS;
266 }
267 
IsTokenUniqueIdExist(uint32_t tokenUniqueId)268 static int32_t IsTokenUniqueIdExist(uint32_t tokenUniqueId)
269 {
270     NativeTokenList *tokenNode = g_tokenListHead->next;
271     while (tokenNode != NULL) {
272         AtInnerInfo *existToken = (AtInnerInfo *)&(tokenNode->tokenId);
273         if (tokenUniqueId == existToken->tokenUniqueId) {
274             return 1;
275         }
276         tokenNode = tokenNode->next;
277     }
278     return 0;
279 }
280 
CreateNativeTokenId(const char * processName)281 static NativeAtId CreateNativeTokenId(const char *processName)
282 {
283     uint32_t rand;
284     NativeAtId tokenId;
285     AtInnerInfo *innerId = (AtInnerInfo *)(&tokenId);
286     int32_t retry = MAX_RETRY_TIMES;
287 
288     while (retry > 0) {
289         if (GetRandomTokenId(&rand) != ATRET_SUCCESS) {
290             return INVALID_TOKEN_ID;
291         }
292         if (IsTokenUniqueIdExist(rand & (TOKEN_RANDOM_MASK)) == 0) {
293             break;
294         }
295         retry--;
296     }
297     if (retry == 0) {
298         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:retry times is 0.", __func__);
299         return INVALID_TOKEN_ID;
300     }
301 
302     innerId->reserved = 0;
303     innerId->tokenUniqueId = rand & (TOKEN_RANDOM_MASK);
304     innerId->version = 1;
305 
306     if (strcmp(processName, HDC_PROCESS_NAME) == 0) {
307         innerId->type = TOKEN_SHELL_TYPE;
308     } else {
309         innerId->type = TOKEN_NATIVE_TYPE;
310     }
311 
312     return tokenId;
313 }
314 
GetAplLevel(const char * aplStr)315 static int32_t GetAplLevel(const char *aplStr)
316 {
317     if (aplStr == NULL) {
318         return 0;
319     }
320     if (strcmp(aplStr, "system_core") == 0) {
321         return SYSTEM_CORE; // system_core means apl level is 3
322     }
323     if (strcmp(aplStr, "system_basic") == 0) {
324         return SYSTEM_BASIC; // system_basic means apl level is 2
325     }
326     if (strcmp(aplStr, "normal") == 0) {
327         return NORMAL;
328     }
329     NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:aplStr is invalid.", __func__);
330     return 0;
331 }
332 
WriteToFile(const cJSON * root)333 static void WriteToFile(const cJSON *root)
334 {
335     char *jsonStr = NULL;
336     jsonStr = cJSON_PrintUnformatted(root);
337     if (jsonStr == NULL) {
338         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:cJSON_PrintUnformatted failed.", __func__);
339         return;
340     }
341 
342     do {
343         int32_t fd = open(TOKEN_ID_CFG_FILE_PATH, O_RDWR | O_CREAT | O_TRUNC,
344                           S_IRUSR | S_IWUSR | S_IRGRP);
345         if (fd < 0) {
346             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:open failed.", __func__);
347             break;
348         }
349         size_t strLen = strlen(jsonStr);
350         ssize_t writtenLen = write(fd, (void *)jsonStr, (size_t)strLen);
351         if (fsync(fd) != 0) {
352             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:fsync failed, errno is %d.", __func__, errno);
353         }
354         close(fd);
355         if (writtenLen < 0 || (size_t)writtenLen != strLen) {
356             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:write failed, writtenLen is %zu.", __func__, writtenLen);
357             break;
358         }
359     } while (0);
360 
361     cJSON_free(jsonStr);
362     return;
363 }
364 
SaveTokenIdToCfg(const NativeTokenList * curr)365 static void SaveTokenIdToCfg(const NativeTokenList *curr)
366 {
367     char *fileBuff = NULL;
368     cJSON *record = NULL;
369     int32_t ret;
370 
371     ret = GetFileBuff(TOKEN_ID_CFG_FILE_PATH, &fileBuff);
372     if (ret != ATRET_SUCCESS) {
373         return;
374     }
375 
376     if (fileBuff == NULL) {
377         record = cJSON_CreateArray();
378     } else {
379         record = cJSON_Parse(fileBuff);
380         free(fileBuff);
381         fileBuff = NULL;
382     }
383 
384     if (record == NULL) {
385         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:get record failed.", __func__);
386         return;
387     }
388 
389     cJSON *node = CreateNativeTokenJsonObject(curr);
390     if (node == NULL) {
391         cJSON_Delete(record);
392         return;
393     }
394     cJSON_AddItemToArray(record, node);
395 
396     WriteToFile(record);
397     cJSON_Delete(record);
398     return;
399 }
400 
CheckStrArray(const char ** strArray,int32_t strNum,int32_t maxNum,uint32_t maxInfoLen)401 static uint32_t CheckStrArray(const char **strArray, int32_t strNum, int32_t maxNum, uint32_t maxInfoLen)
402 {
403     if (((strArray == NULL) && (strNum != 0)) ||
404         (strNum > maxNum) || (strNum < 0)) {
405         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:strArray is null or strNum is invalid.", __func__);
406         return ATRET_FAILED;
407     }
408     for (int32_t i = 0; i < strNum; i++) {
409         if ((strArray[i] == NULL) || (strlen(strArray[i]) > maxInfoLen) || (strlen(strArray[i]) == 0)) {
410             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:strArray[%d] length is invalid.", __func__, i);
411             return ATRET_FAILED;
412         }
413     }
414     return ATRET_SUCCESS;
415 }
416 
CheckProcessInfo(NativeTokenInfoParams * tokenInfo,int32_t * aplRet)417 static uint32_t CheckProcessInfo(NativeTokenInfoParams *tokenInfo, int32_t *aplRet)
418 {
419     if ((tokenInfo->processName == NULL) || strlen(tokenInfo->processName) > MAX_PROCESS_NAME_LEN ||
420         strlen(tokenInfo->processName) == 0) {
421         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:processName is invalid.", __func__);
422         return ATRET_FAILED;
423     }
424     uint32_t retDcap = CheckStrArray(tokenInfo->dcaps, tokenInfo->dcapsNum, MAX_DCAPS_NUM, MAX_DCAP_LEN);
425     if (retDcap != ATRET_SUCCESS) {
426         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:dcaps is invalid.", __func__);
427         return ATRET_FAILED;
428     }
429     uint32_t retPerm = CheckStrArray(tokenInfo->perms, tokenInfo->permsNum, MAX_PERM_NUM, MAX_PERM_LEN);
430     if (retPerm != ATRET_SUCCESS) {
431         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:perms is invalid.", __func__);
432         return ATRET_FAILED;
433     }
434 
435     uint32_t retAcl = CheckStrArray(tokenInfo->acls, tokenInfo->aclsNum, MAX_PERM_NUM, MAX_PERM_LEN);
436     if (retAcl != ATRET_SUCCESS) {
437         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:acls is invalid.", __func__);
438         return ATRET_FAILED;
439     }
440 
441     if (tokenInfo->aclsNum > tokenInfo->permsNum) {
442         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:aclsNum is invalid.", __func__);
443         return ATRET_FAILED;
444     }
445     int32_t apl = GetAplLevel(tokenInfo->aplStr);
446     if (apl == 0) {
447         return ATRET_FAILED;
448     }
449     *aplRet = apl;
450     return ATRET_SUCCESS;
451 }
452 
CreateStrArray(int32_t num,const char ** strArr,char ** strArrRes)453 static uint32_t CreateStrArray(int32_t num, const char **strArr, char **strArrRes)
454 {
455     for (int32_t i = 0; i < num; i++) {
456         strArrRes[i] = (char *)malloc(sizeof(char) * (strlen(strArr[i]) + 1));
457         if (strArrRes[i] == NULL ||
458             (strcpy_s(strArrRes[i], strlen(strArr[i]) + 1, strArr[i]) != EOK)) {
459             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:copy strArr[%d] failed.", __func__, i);
460             FreeStrArray(strArrRes, i);
461             return ATRET_FAILED;
462         }
463     }
464     return ATRET_SUCCESS;
465 }
466 
AddNewTokenToListAndFile(const NativeTokenInfoParams * tokenInfo,int32_t aplIn,NativeAtId * tokenId)467 static uint32_t AddNewTokenToListAndFile(const NativeTokenInfoParams *tokenInfo,
468     int32_t aplIn, NativeAtId *tokenId)
469 {
470     NativeTokenList *tokenNode;
471     NativeAtId id;
472 
473     id = CreateNativeTokenId(tokenInfo->processName);
474     if (id == INVALID_TOKEN_ID) {
475         return ATRET_FAILED;
476     }
477 
478     tokenNode = (NativeTokenList *)malloc(sizeof(NativeTokenList));
479     if (tokenNode == NULL) {
480         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:memory alloc failed.", __func__);
481         return ATRET_FAILED;
482     }
483     tokenNode->tokenId = id;
484     tokenNode->apl = aplIn;
485     if (strcpy_s(tokenNode->processName, MAX_PROCESS_NAME_LEN + 1, tokenInfo->processName) != EOK) {
486         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:strcpy_s failed.", __func__);
487         free(tokenNode);
488         return ATRET_FAILED;
489     }
490     tokenNode->dcapsNum = tokenInfo->dcapsNum;
491     tokenNode->permsNum = tokenInfo->permsNum;
492     tokenNode->aclsNum = tokenInfo->aclsNum;
493 
494     if (CreateStrArray(tokenInfo->dcapsNum, tokenInfo->dcaps, tokenNode->dcaps) != ATRET_SUCCESS) {
495         free(tokenNode);
496         return ATRET_FAILED;
497     }
498     if (CreateStrArray(tokenInfo->permsNum, tokenInfo->perms, tokenNode->perms) != ATRET_SUCCESS) {
499         FreeStrArray(tokenNode->dcaps, tokenInfo->dcapsNum - 1);
500         free(tokenNode);
501         return ATRET_FAILED;
502     }
503     if (CreateStrArray(tokenInfo->aclsNum, tokenInfo->acls, tokenNode->acls) != ATRET_SUCCESS) {
504         FreeStrArray(tokenNode->dcaps, tokenInfo->dcapsNum - 1);
505         FreeStrArray(tokenNode->perms, tokenInfo->permsNum - 1);
506         free(tokenNode);
507         return ATRET_FAILED;
508     }
509 
510     tokenNode->next = g_tokenListHead->next;
511     g_tokenListHead->next = tokenNode;
512 
513     *tokenId = id;
514 
515     SaveTokenIdToCfg(tokenNode);
516     return ATRET_SUCCESS;
517 }
518 
CompareTokenInfo(const NativeTokenList * tokenNode,const char ** dcapsIn,int32_t dcapNumIn,int32_t aplIn)519 static int32_t CompareTokenInfo(const NativeTokenList *tokenNode,
520                                 const char **dcapsIn, int32_t dcapNumIn, int32_t aplIn)
521 {
522     if (tokenNode->apl != aplIn) {
523         return 1;
524     }
525     if (tokenNode->dcapsNum != dcapNumIn) {
526         return 1;
527     }
528     for (int32_t i = 0; i < dcapNumIn; i++) {
529         if (strcmp(tokenNode->dcaps[i], dcapsIn[i]) != 0) {
530             return 1;
531         }
532     }
533     return 0;
534 }
535 
ComparePermsInfo(const NativeTokenList * tokenNode,const char ** permsIn,int32_t permsNumIn)536 static int32_t ComparePermsInfo(const NativeTokenList *tokenNode,
537                                 const char **permsIn, int32_t permsNumIn)
538 {
539     if (tokenNode->permsNum != permsNumIn) {
540         return 1;
541     }
542     for (int32_t i = 0; i < permsNumIn; i++) {
543         if (strcmp(tokenNode->perms[i], permsIn[i]) != 0) {
544             return 1;
545         }
546     }
547     return 0;
548 }
549 
UpdateStrArrayInList(char * strArr[],int32_t * strNum,const char ** strArrNew,int32_t strNumNew)550 static uint32_t UpdateStrArrayInList(char *strArr[], int32_t *strNum,
551     const char **strArrNew, int32_t strNumNew)
552 {
553     if (strNum == NULL) {
554         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:strNum length is invalid.", __func__);
555         return ATRET_FAILED;
556     }
557     for (int32_t i = 0; i < *strNum; i++) {
558         free(strArr[i]);
559         strArr[i] = NULL;
560     }
561 
562     *strNum = strNumNew;
563     for (int32_t i = 0; i < strNumNew; i++) {
564         size_t len = strlen(strArrNew[i]) + 1;
565         strArr[i] = (char *)malloc(sizeof(char) * len);
566         if (strArr[i] == NULL || (strcpy_s(strArr[i], len, strArrNew[i]) != EOK)) {
567             NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:copy strArr[%d] failed.", __func__, i);
568             FreeStrArray(strArr, i);
569             return ATRET_FAILED;
570         }
571     }
572     return ATRET_SUCCESS;
573 }
574 
UpdateTokenInfoInList(NativeTokenList * tokenNode,const NativeTokenInfoParams * tokenInfo)575 static uint32_t UpdateTokenInfoInList(NativeTokenList *tokenNode,
576                                       const NativeTokenInfoParams *tokenInfo)
577 {
578     tokenNode->apl = GetAplLevel(tokenInfo->aplStr);
579 
580     uint32_t ret = UpdateStrArrayInList(tokenNode->dcaps, &(tokenNode->dcapsNum),
581         tokenInfo->dcaps, tokenInfo->dcapsNum);
582     if (ret != ATRET_SUCCESS) {
583         return ret;
584     }
585     ret = UpdateStrArrayInList(tokenNode->perms, &(tokenNode->permsNum),
586         tokenInfo->perms, tokenInfo->permsNum);
587     if (ret != ATRET_SUCCESS) {
588         FreeStrArray(tokenNode->dcaps, tokenNode->dcapsNum - 1);
589     }
590     ret = UpdateStrArrayInList(tokenNode->acls, &(tokenNode->aclsNum),
591         tokenInfo->acls, tokenInfo->aclsNum);
592     if (ret != ATRET_SUCCESS) {
593         FreeStrArray(tokenNode->dcaps, tokenNode->dcapsNum - 1);
594         FreeStrArray(tokenNode->perms, tokenNode->permsNum - 1);
595     }
596     return ret;
597 }
598 
UpdateInfoInCfgFile(const NativeTokenList * tokenNode)599 static uint32_t UpdateInfoInCfgFile(const NativeTokenList *tokenNode)
600 {
601     cJSON *record = NULL;
602     char *fileBuffer = NULL;
603     uint32_t ret;
604 
605     if (GetFileBuff(TOKEN_ID_CFG_FILE_PATH, &fileBuffer) != ATRET_SUCCESS) {
606         return ATRET_FAILED;
607     }
608 
609     if (fileBuffer == NULL) {
610         record = cJSON_CreateArray();
611     } else {
612         record = cJSON_Parse(fileBuffer);
613         free(fileBuffer);
614         fileBuffer = NULL;
615     }
616 
617     if (record == NULL) {
618         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:get record failed.", __func__);
619         return ATRET_FAILED;
620     }
621 
622     ret = UpdateGoalItemFromRecord(tokenNode, record);
623     if (ret != ATRET_SUCCESS) {
624         NativeTokenKmsg(NATIVETOKEN_KERROR, "[%s]:UpdateGoalItemFromRecord failed.", __func__);
625         cJSON_Delete(record);
626         return ATRET_FAILED;
627     }
628 
629     WriteToFile(record);
630     cJSON_Delete(record);
631     return ATRET_SUCCESS;
632 }
633 
GetAccessTokenId(NativeTokenInfoParams * tokenInfo)634 uint64_t GetAccessTokenId(NativeTokenInfoParams *tokenInfo)
635 {
636     NativeAtId tokenId = 0;
637     uint64_t result = 0;
638     int32_t apl;
639     NativeAtIdEx *atPoint = (NativeAtIdEx *)(&result);
640 
641     if ((g_isNativeTokenInited == 0) && (AtlibInit() != ATRET_SUCCESS)) {
642         return INVALID_TOKEN_ID;
643     }
644     uint32_t ret = CheckProcessInfo(tokenInfo, &apl);
645     if (ret != ATRET_SUCCESS) {
646         return INVALID_TOKEN_ID;
647     }
648 
649     NativeTokenList *tokenNode = g_tokenListHead->next;
650     while (tokenNode != NULL) {
651         if (strcmp(tokenNode->processName, tokenInfo->processName) == 0) {
652             tokenId = tokenNode->tokenId;
653             break;
654         }
655         tokenNode = tokenNode->next;
656     }
657 
658     if (tokenNode == NULL) {
659         ret = AddNewTokenToListAndFile(tokenInfo, apl, &tokenId);
660     } else {
661         int32_t needTokenUpdate = CompareTokenInfo(tokenNode, tokenInfo->dcaps, tokenInfo->dcapsNum, apl);
662         int32_t needPermUpdate = ComparePermsInfo(tokenNode, tokenInfo->perms, tokenInfo->permsNum);
663         if ((needTokenUpdate != 0) || (needPermUpdate != 0)) {
664             ret = UpdateTokenInfoInList(tokenNode, tokenInfo);
665             ret |= UpdateInfoInCfgFile(tokenNode);
666         }
667     }
668     if (ret != ATRET_SUCCESS) {
669         return INVALID_TOKEN_ID;
670     }
671 
672     atPoint->tokenId = tokenId;
673     atPoint->tokenAttr = 0;
674     return result;
675 }
676