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