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