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