1 /*
2 * Copyright (c) 2023 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
16 #include <gtest/gtest.h>
17 #include <gtest/hwext/gtest-multithread.h>
18
19 #include "cm_test_common.h"
20
21 #include "cert_manager_api.h"
22
23 using namespace testing::ext;
24 using namespace testing::mt;
25 using namespace CertmanagerTest;
26 namespace {
27 static uint32_t g_selfTokenId = 0;
28 static MockHapToken* g_MockHap = nullptr;
29 static constexpr uint32_t DEFAULT_AUTH_URI_LEN = 256;
30 static constexpr uint32_t DEFAULT_BASE_APP_ID = 1000;
31 static constexpr uint32_t APP_UID_COUNT_ONE = 1;
32 static constexpr uint32_t APP_UID_COUNT_MULTI = 10;
33 static constexpr uint32_t APP_UID_REMOVE_COUNT = 4;
34 static constexpr uint32_t DEFAULT_APP_UID_COUNT = 256;
35 static constexpr uint32_t MULTI_THREAD_NUM = 10;
36 static uint32_t g_checkListItemCount = 0;
37 static uint32_t g_checkBaseAppId = 0;
38
39 class CmGetAuthListMultiThreadTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42
43 static void TearDownTestCase(void);
44
45 void SetUp();
46
47 void TearDown();
48 };
49
SetUpTestCase(void)50 void CmGetAuthListMultiThreadTest::SetUpTestCase(void)
51 {
52 g_selfTokenId = GetSelfTokenID();
53 CmTestCommon::SetTestEnvironment(g_selfTokenId);
54 }
55
TearDownTestCase(void)56 void CmGetAuthListMultiThreadTest::TearDownTestCase(void)
57 {
58 CmTestCommon::ResetTestEnvironment();
59 }
60
61 static const uint8_t g_uriData[] = "oh:t=ak;o=GetAuthList;u=0;a=0";
62 static const CmBlob g_keyUri = { sizeof(g_uriData), (uint8_t *)g_uriData };
63
SetUp()64 void CmGetAuthListMultiThreadTest::SetUp()
65 {
66 g_MockHap = new (std::nothrow) MockHapToken();
67 uint8_t aliasData[] = "GetAuthList";
68 struct CmBlob alias = { sizeof(aliasData), aliasData };
69
70 int32_t ret = TestGenerateAppCert(&alias, CERT_KEY_ALG_RSA, CM_CREDENTIAL_STORE);
71 EXPECT_EQ(ret, CM_SUCCESS) << "TestGenerateAppCert failed, retcode:" << ret;
72
73 uint32_t appId = DEFAULT_BASE_APP_ID;
74 uint8_t authUriData[DEFAULT_AUTH_URI_LEN] = {0};
75 struct CmBlob authUri = { DEFAULT_AUTH_URI_LEN, authUriData };
76
77 ret = CmGrantAppCertificate(&g_keyUri, appId, &authUri);
78 EXPECT_EQ(ret, CM_SUCCESS) << "CmGrantAppCertificate failed, retcode:" << ret;
79 }
80
TearDown()81 void CmGetAuthListMultiThreadTest::TearDown()
82 {
83 int32_t ret = CmUninstallAppCert(&g_keyUri, CM_CREDENTIAL_STORE);
84 EXPECT_EQ(ret, CM_SUCCESS) << "CmUninstallAppCert failed, retcode:" << ret;
85
86 uint32_t appUid[DEFAULT_APP_UID_COUNT] = {0};
87 struct CmAppUidList appUidList = { DEFAULT_APP_UID_COUNT, appUid };
88 ret = CmGetAuthorizedAppList(&g_keyUri, &appUidList);
89 EXPECT_EQ(ret, CM_SUCCESS) << "CmGetAuthorizedAppList failed, retcode:" << ret;
90
91 uint32_t expectCount = 0;
92 EXPECT_EQ(appUidList.appUidCount, expectCount);
93 if (g_MockHap != nullptr) {
94 delete g_MockHap;
95 g_MockHap = nullptr;
96 }
97 }
98
TestRemoveGrant(uint32_t count,uint32_t baseAppId)99 static void TestRemoveGrant(uint32_t count, uint32_t baseAppId)
100 {
101 int32_t ret;
102 uint32_t appId;
103 for (uint32_t i = 0; i < count; ++i) {
104 appId = baseAppId + i;
105 ret = CmRemoveGrantedApp(&g_keyUri, appId);
106 EXPECT_EQ(ret, CM_SUCCESS) << "CmRemoveGrantedApp failed, retcode:" << ret;
107 }
108 }
109
TestGrant(uint32_t count,uint32_t baseAppId)110 static void TestGrant(uint32_t count, uint32_t baseAppId)
111 {
112 uint32_t appId;
113 uint8_t authUriData[DEFAULT_AUTH_URI_LEN] = {0};
114 struct CmBlob authUri = { DEFAULT_AUTH_URI_LEN, authUriData };
115
116 int32_t ret;
117 for (uint32_t i = 0; i < count; ++i) {
118 appId = baseAppId + i;
119 authUri.size = DEFAULT_AUTH_URI_LEN;
120 ret = CmGrantAppCertificate(&g_keyUri, appId, &authUri);
121 EXPECT_EQ(ret, CM_SUCCESS) << "CmGrantAppCertificate failed, retcode:" << ret;
122 ret = CmIsAuthorizedApp(&authUri);
123 EXPECT_EQ(ret, CM_SUCCESS) << "CmIsAuthorizedApp failed, retcode:" << ret;
124 }
125 }
126
TestGetAuthedList(void)127 static void TestGetAuthedList(void)
128 {
129 uint32_t appUid[DEFAULT_APP_UID_COUNT] = {0};
130 struct CmAppUidList appUidList = { DEFAULT_APP_UID_COUNT, appUid };
131 int32_t ret = CmGetAuthorizedAppList(&g_keyUri, &appUidList);
132 EXPECT_EQ(ret, CM_SUCCESS) << "CmGetAuthorizedAppList failed, retcode:" << ret;
133 EXPECT_EQ(appUidList.appUidCount, g_checkListItemCount);
134
135 uint32_t uidValidCount = 0;
136 for (uint32_t i = 0; i < g_checkListItemCount; ++i) {
137 for (uint32_t j = 0; j < appUidList.appUidCount; ++j) {
138 if ((g_checkBaseAppId + i) == appUidList.appUid[j]) {
139 uidValidCount++;
140 }
141 }
142 }
143 EXPECT_EQ(uidValidCount, g_checkListItemCount);
144 }
145
146 /**
147 * @tc.name: CmGetAuthListMultiThreadTest001
148 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri is NULL
149 * @tc.type: FUNC
150 * @tc.require: AR000H0MIA /SR000H09NA
151 */
152 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest001, TestSize.Level0, MULTI_THREAD_NUM)
153 {
154 struct CmBlob *keyUri = nullptr; /* keyUri is NULL */
155 struct CmAppUidList appUidList = { 0, nullptr };
156 int32_t ret = CmGetAuthorizedAppList(keyUri, &appUidList);
157 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
158 }
159
160 /**
161 * @tc.name: CmGetAuthListMultiThreadTest002
162 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri size is 0
163 * @tc.type: FUNC
164 * @tc.require: AR000H0MIA /SR000H09NA
165 */
166 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest002, TestSize.Level0, MULTI_THREAD_NUM)
167 {
168 uint8_t uriData[] = "oh:t=ak;o=keyA;u=0;a=0";
169 struct CmBlob keyUri = { 0, uriData }; /* keyUri size is 0 */
170 struct CmAppUidList appUidList = { 0, nullptr };
171 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList);
172 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
173 }
174
175 /**
176 * @tc.name: CmGetAuthListMultiThreadTest003
177 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri data is null
178 * @tc.type: FUNC
179 * @tc.require: AR000H0MIA /SR000H09NA
180 */
181 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest003, TestSize.Level0, MULTI_THREAD_NUM)
182 {
183 uint8_t uriData[] = "oh:t=ak;o=keyA;u=0;a=0";
184 struct CmBlob keyUri = { sizeof(uriData), nullptr }; /* keyUri data is null */
185 struct CmAppUidList appUidList = { 0, nullptr };
186 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList);
187 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
188 }
189
190 /**
191 * @tc.name: CmGetAuthListMultiThreadTest004
192 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri data not end of '\0'
193 * @tc.type: FUNC
194 * @tc.require: AR000H0MIA /SR000H09NA
195 */
196 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest004, TestSize.Level0, MULTI_THREAD_NUM)
197 {
198 uint8_t uriData[] = "oh:t=ak;o=keyA;u=0;a=0";
199 struct CmBlob keyUri = { strlen((char *)uriData), uriData }; /* keyUri data not end of '\0' */
200 struct CmAppUidList appUidList = { 0, nullptr };
201 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList);
202 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
203 }
204
205 /**
206 * @tc.name: CmGetAuthListMultiThreadTest005
207 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri data has no app
208 * @tc.type: FUNC
209 * @tc.require: AR000H0MIA /SR000H09NA
210 */
211 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest005, TestSize.Level0, MULTI_THREAD_NUM)
212 {
213 /* keyUri data has no app */
214 uint8_t uriData[] = "oh:t=ak;o=keyA;u=0";
215 struct CmBlob keyUri = { sizeof(uriData), uriData };
216 struct CmAppUidList appUidList = { 0, nullptr };
217 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList);
218 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
219 }
220
221 /**
222 * @tc.name: CmGetAuthListMultiThreadTest006
223 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri data has no user
224 * @tc.type: FUNC
225 * @tc.require: AR000H0MIA /SR000H09NA
226 */
227 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest006, TestSize.Level0, MULTI_THREAD_NUM)
228 {
229 /* keyUri data has no user */
230 uint8_t uriData[] = "oh:t=ak;o=keyA;a=0";
231 struct CmBlob keyUri = { sizeof(uriData), uriData };
232 struct CmAppUidList appUidList = { 0, nullptr };
233 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList);
234 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
235 }
236
237 /**
238 * @tc.name: CmGetAuthListMultiThreadTest007
239 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri data has no object
240 * @tc.type: FUNC
241 * @tc.require: AR000H0MIA /SR000H09NA
242 */
243 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest007, TestSize.Level0, MULTI_THREAD_NUM)
244 {
245 /* keyUri data has no object */
246 uint8_t uriData[] = "oh:t=ak;u=0;a=0";
247 struct CmBlob keyUri = { sizeof(uriData), uriData };
248 struct CmAppUidList appUidList = { 0, nullptr };
249 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList);
250 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
251 }
252
253 /**
254 * @tc.name: CmGetAuthListMultiThreadTest008
255 * @tc.desc: Test CmGetAuthListMultiThreadTest keyUri data type not ak
256 * @tc.type: FUNC
257 * @tc.require: AR000H0MIA /SR000H09NA
258 */
259 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest008, TestSize.Level0, MULTI_THREAD_NUM)
260 {
261 /* keyUri data type not ak */
262 uint8_t uriData[] = "oh:t=m;o=keyA;u=0;a=0";
263 struct CmBlob keyUri = { sizeof(uriData), uriData };
264 struct CmAppUidList appUidList = { 0, nullptr };
265 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList);
266 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
267 }
268
269 /**
270 * @tc.name: CmGetAuthListMultiThreadTest009
271 * @tc.desc: Test CmGetAuthListMultiThreadTest authUriList is NULL
272 * @tc.type: FUNC
273 * @tc.require: AR000H0MIA /SR000H09NA
274 */
275 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest009, TestSize.Level0, MULTI_THREAD_NUM)
276 {
277 uint8_t uriData[] = "oh:t=ak;o=keyA;u=0;a=0";
278 struct CmBlob keyUri = { sizeof(uriData), uriData };
279 struct CmAppUidList *appUidList = nullptr; /* authUriList is NULL */
280 int32_t ret = CmGetAuthorizedAppList(&keyUri, appUidList);
281 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
282 }
283
284 /**
285 * @tc.name: CmGetAuthListMultiThreadTest010
286 * @tc.desc: Test CmGetAuthListMultiThreadTest authlist count too small
287 * @tc.type: FUNC
288 * @tc.require: AR000H0MIA /SR000H09NA
289 */
290 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest010, TestSize.Level0, MULTI_THREAD_NUM)
291 {
292 struct CmAppUidList appUidList = { 0, nullptr };
293 int32_t ret = CmGetAuthorizedAppList(&g_keyUri, &appUidList);
294 EXPECT_EQ(ret, CMR_ERROR_BUFFER_TOO_SMALL);
295 }
296
297 /**
298 * @tc.name: CmGetAuthListMultiThreadTest011
299 * @tc.desc: Test CmGetAuthListMultiThreadTest authlist data NULL
300 * @tc.type: FUNC
301 * @tc.require: AR000H0MIA /SR000H09NA
302 */
303 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest011, TestSize.Level0, MULTI_THREAD_NUM)
304 {
305 struct CmAppUidList appUidList = { APP_UID_COUNT_ONE, nullptr }; /* setup has granted 1 app uid */
306 int32_t ret = CmGetAuthorizedAppList(&g_keyUri, &appUidList);
307 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
308 }
309
310 /**
311 * @tc.name: CmGetAuthListMultiThreadTest012
312 * @tc.desc: Test CmGetAuthListMultiThreadTest authlist count too big > MAX_OUT_BLOB_SIZE
313 * @tc.type: FUNC
314 * @tc.require: AR000H0MIA /SR000H09NA
315 */
316 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest012, TestSize.Level0, MULTI_THREAD_NUM)
317 {
318 struct CmAppUidList appUidList = { MAX_OUT_BLOB_SIZE + 1, nullptr }; /* count too big */
319 int32_t ret = CmGetAuthorizedAppList(&g_keyUri, &appUidList);
320 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
321 }
322
323 /**
324 * @tc.name: CmGetAuthListMultiThreadTest013
325 * @tc.desc: Test CmGetAuthListMultiThreadTest not grant, get grant list { 0, NULL }
326 * @tc.type: FUNC
327 * @tc.require: AR000H0MIA /SR000H09NA
328 */
329 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest013, TestSize.Level0, MULTI_THREAD_NUM)
330 {
331 uint8_t uriData[] = "oh:t=ak;o=keyA;u=0;a=0";
332 struct CmBlob keyUri = { sizeof(uriData), uriData };
333 struct CmAppUidList appUidList = { 0, nullptr };
334
335 int32_t ret = CmGetAuthorizedAppList(&keyUri, &appUidList); /* auth uid not exist */
336 EXPECT_EQ(ret, CM_SUCCESS);
337
338 uint32_t expectCount = 0;
339 EXPECT_EQ(appUidList.appUidCount, expectCount);
340 }
341
342 /**
343 * @tc.name: CmGetAuthListMultiThreadTest014
344 * @tc.desc: Test CmGetAuthListMultiThreadTest grant 1, get authlist
345 * @tc.type: FUNC
346 * @tc.require: AR000H0MIA /SR000H09NA
347 */
348 HWMTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest014, TestSize.Level0, MULTI_THREAD_NUM)
349 {
350 uint32_t tempUid = 0;
351 struct CmAppUidList appUidList = { APP_UID_COUNT_ONE, &tempUid };
352
353 int32_t ret = CmGetAuthorizedAppList(&g_keyUri, &appUidList);
354 EXPECT_EQ(ret, CM_SUCCESS);
355 EXPECT_EQ(appUidList.appUidCount, APP_UID_COUNT_ONE);
356 EXPECT_EQ(*(appUidList.appUid), DEFAULT_BASE_APP_ID);
357 }
358
359 /**
360 * @tc.name: CmGetAuthListMultiThreadTest015
361 * @tc.desc: Test CmGetAuthListMultiThreadTest grant 10, get authlist
362 * @tc.type: FUNC
363 * @tc.require: AR000H0MIA /SR000H09NA
364 */
365 HWTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest015, TestSize.Level0)
366 {
367 TestGrant(APP_UID_COUNT_MULTI, DEFAULT_BASE_APP_ID);
368 g_checkListItemCount = APP_UID_COUNT_MULTI;
369 g_checkBaseAppId = DEFAULT_BASE_APP_ID;
370 SET_THREAD_NUM(MULTI_THREAD_NUM);
371 GTEST_RUN_TASK(TestGetAuthedList);
372
373 /* clear environment */
374 TestRemoveGrant(APP_UID_COUNT_MULTI, DEFAULT_BASE_APP_ID);
375 g_checkListItemCount = 0;
376 g_checkBaseAppId = 0;
377 GTEST_RUN_TASK(TestGetAuthedList);
378 }
379
380 /**
381 * @tc.name: CmGetAuthListMultiThreadTest016
382 * @tc.desc: Test CmGetAuthListMultiThreadTest grant 10, remove grant 4, get authlist
383 * @tc.type: FUNC
384 * @tc.require: AR000H0MIA /SR000H09NA
385 */
386 HWTEST_F(CmGetAuthListMultiThreadTest, CmGetAuthListMultiThreadTest016, TestSize.Level0)
387 {
388 TestGrant(APP_UID_COUNT_MULTI, DEFAULT_BASE_APP_ID);
389 g_checkListItemCount = APP_UID_COUNT_MULTI;
390 g_checkBaseAppId = DEFAULT_BASE_APP_ID;
391 SET_THREAD_NUM(MULTI_THREAD_NUM);
392 GTEST_RUN_TASK(TestGetAuthedList);
393
394 uint32_t remainCount = APP_UID_COUNT_MULTI - APP_UID_REMOVE_COUNT;
395 uint32_t remainBaseAppId = DEFAULT_BASE_APP_ID + APP_UID_REMOVE_COUNT;
396
397 if (APP_UID_REMOVE_COUNT != 0) {
398 TestRemoveGrant(APP_UID_REMOVE_COUNT, DEFAULT_BASE_APP_ID);
399 g_checkListItemCount = remainCount;
400 g_checkBaseAppId = remainBaseAppId;
401 GTEST_RUN_TASK(TestGetAuthedList);
402 }
403
404 /* clear environment */
405 TestRemoveGrant(remainCount, remainBaseAppId);
406 g_checkListItemCount = 0;
407 g_checkBaseAppId = 0;
408 GTEST_RUN_TASK(TestGetAuthedList);
409 }
410 } // end of namespace
411
412