1 /*
2 * Copyright (c) 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
16 #include <gtest/gtest.h>
17
18 #include "cm_test_common.h"
19
20 #include "cert_manager_api.h"
21
22 using namespace testing::ext;
23 using namespace CertmanagerTest;
24 namespace {
25 class CmCommonPermissionTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28
29 static void TearDownTestCase(void);
30
31 void SetUp();
32
33 void TearDown();
34 };
35
SetUpTestCase(void)36 void CmCommonPermissionTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void CmCommonPermissionTest::TearDownTestCase(void)
41 {
42 }
43
SetUp()44 void CmCommonPermissionTest::SetUp()
45 {
46 }
47
TearDown()48 void CmCommonPermissionTest::TearDown()
49 {
50 }
51
52 /**
53 * @tc.name: CmCommonPermissionTest001
54 * @tc.desc: test CmGetAppCertList
55 * @tc.type: FUNC
56 * @tc.require: AR000H0MIA /SR000H09NA
57 */
58 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest001, TestSize.Level0)
59 {
60 struct CertList *certList = nullptr;
61 int32_t ret = InitCertList(&certList);
62 ASSERT_EQ(ret, CM_SUCCESS);
63
64 ret = CmGetCertList(CM_SYSTEM_TRUSTED_STORE, certList);
65 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
66
67 FreeCertList(certList);
68 }
69
70 /**
71 * @tc.name: CmCommonPermissionTest002
72 * @tc.desc: test CmGetCertInfo
73 * @tc.type: FUNC
74 * @tc.require: AR000H0MIA /SR000H09NA
75 */
76 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest002, TestSize.Level0)
77 {
78 struct CertInfo info;
79 (void)memset_s(&info, sizeof(struct CertInfo), 0, sizeof(struct CertInfo));
80 int32_t ret = InitCertInfo(&info);
81 ASSERT_EQ(ret, CM_SUCCESS);
82
83 uint8_t uriData[] = "CmCommonPermissionTest002";
84 struct CmBlob uri = { sizeof(uriData), uriData };
85 ret = CmGetCertInfo(&uri, CM_SYSTEM_TRUSTED_STORE, &info);
86 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
87
88 FreeCMBlobData(&info.certInfo);
89 }
90
91 /**
92 * @tc.name: CmCommonPermissionTest003
93 * @tc.desc: test CmSetCertStatus
94 * @tc.type: FUNC
95 * @tc.require: AR000H0MIA /SR000H09NA
96 */
97 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest003, TestSize.Level0)
98 {
99 uint8_t uriData[] = "CmCommonPermissionTest003";
100 struct CmBlob uri = { sizeof(uriData), uriData };
101 int32_t ret = CmSetCertStatus(&uri, CM_SYSTEM_TRUSTED_STORE, false);
102 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
103 }
104
105 /**
106 * @tc.name: CmCommonPermissionTest004
107 * @tc.desc: test CmInstallAppCert pub credential
108 * @tc.type: FUNC
109 * @tc.require: AR000H0MIA /SR000H09NA
110 */
111 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest004, TestSize.Level0)
112 {
113 uint8_t aliasData[] = "Common004";
114 struct CmBlob alias = { sizeof(aliasData), aliasData };
115 int32_t ret = TestGenerateAppCert(&alias, CERT_KEY_ALG_RSA, CM_CREDENTIAL_STORE);
116 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
117 }
118
119 /**
120 * @tc.name: CmCommonPermissionTest005
121 * @tc.desc: test CmInstallAppCert pri credential
122 * @tc.type: FUNC
123 * @tc.require: AR000H0MIA /SR000H09NA
124 */
125 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest005, TestSize.Level0)
126 {
127 uint8_t aliasData[] = "Common005";
128 struct CmBlob alias = { sizeof(aliasData), aliasData };
129 int32_t ret = TestGenerateAppCert(&alias, CERT_KEY_ALG_RSA, CM_PRI_CREDENTIAL_STORE);
130 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
131 }
132
133 /**
134 * @tc.name: CmCommonPermissionTest006
135 * @tc.desc: test CmUninstallAppCert pub credential
136 * @tc.type: FUNC
137 * @tc.require: AR000H0MIA /SR000H09NA
138 */
139 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest006, TestSize.Level0)
140 {
141 uint8_t uriData[] = "Common006";
142 struct CmBlob uri = { sizeof(uriData), uriData };
143 int32_t ret = CmUninstallAppCert(&uri, CM_CREDENTIAL_STORE);
144 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
145 }
146
147 /**
148 * @tc.name: CmCommonPermissionTest007
149 * @tc.desc: test CmUninstallAppCert pri credential
150 * @tc.type: FUNC
151 * @tc.require: AR000H0MIA /SR000H09NA
152 */
153 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest007, TestSize.Level0)
154 {
155 uint8_t uriData[] = "Common007";
156 struct CmBlob uri = { sizeof(uriData), uriData };
157 int32_t ret = CmUninstallAppCert(&uri, CM_PRI_CREDENTIAL_STORE);
158 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
159 }
160
161 /**
162 * @tc.name: CmCommonPermissionTest008
163 * @tc.desc: test CmUninstallAllAppCert
164 * @tc.type: FUNC
165 * @tc.require: AR000H0MIA /SR000H09NA
166 */
167 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest008, TestSize.Level0)
168 {
169 int32_t ret = CmUninstallAllAppCert();
170 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
171 }
172
173 /**
174 * @tc.name: CmCommonPermissionTest009
175 * @tc.desc: test CmGetAppCertList pub
176 * @tc.type: FUNC
177 * @tc.require: AR000H0MIA /SR000H09NA
178 */
179 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest009, TestSize.Level0)
180 {
181 struct CredentialAbstract abstract[MAX_COUNT_CERTIFICATE];
182 (void)memset_s(abstract, sizeof(abstract), 0, sizeof(abstract));
183 struct CredentialList certList = { MAX_COUNT_CERTIFICATE, abstract };
184 int32_t ret = CmGetAppCertList(CM_CREDENTIAL_STORE, &certList);
185 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
186 }
187
188 /**
189 * @tc.name: CmCommonPermissionTest010
190 * @tc.desc: test CmGetAppCertList pri
191 * @tc.type: FUNC
192 * @tc.require: AR000H0MIA /SR000H09NA
193 */
194 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest010, TestSize.Level0)
195 {
196 struct CredentialAbstract abstract[MAX_COUNT_CERTIFICATE];
197 (void)memset_s(abstract, sizeof(abstract), 0, sizeof(abstract));
198 struct CredentialList certList = { MAX_COUNT_CERTIFICATE, abstract };
199 int32_t ret = CmGetAppCertList(CM_PRI_CREDENTIAL_STORE, &certList);
200 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
201 }
202
203 /**
204 * @tc.name: CmCommonPermissionTest011
205 * @tc.desc: test CmGetAppCert pub
206 * @tc.type: FUNC
207 * @tc.require: AR000H0MIA /SR000H09NA
208 */
209 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest011, TestSize.Level0)
210 {
211 struct Credential cred;
212 (void)memset_s(&cred, sizeof(struct Credential), 0, sizeof(struct Credential));
213 cred.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
214 cred.credData.data = static_cast<uint8_t *>(malloc(MAX_LEN_CERTIFICATE_CHAIN));
215 ASSERT_TRUE(cred.credData.data != nullptr);
216
217 uint8_t uriData[] = "Common011";
218 struct CmBlob uri = { sizeof(uriData), uriData };
219
220 int32_t ret = CmGetAppCert(&uri, CM_CREDENTIAL_STORE, &cred);
221 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
222
223 free(cred.credData.data);
224 }
225
226 /**
227 * @tc.name: CmCommonPermissionTest012
228 * @tc.desc: test CmGetAppCert pri
229 * @tc.type: FUNC
230 * @tc.require: AR000H0MIA /SR000H09NA
231 */
232 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest012, TestSize.Level0)
233 {
234 struct Credential cred;
235 (void)memset_s(&cred, sizeof(struct Credential), 0, sizeof(struct Credential));
236 cred.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
237 cred.credData.data = static_cast<uint8_t *>(malloc(MAX_LEN_CERTIFICATE_CHAIN));
238 ASSERT_TRUE(cred.credData.data != nullptr);
239
240 uint8_t uriData[] = "Common012";
241 struct CmBlob uri = { sizeof(uriData), uriData };
242
243 int32_t ret = CmGetAppCert(&uri, CM_PRI_CREDENTIAL_STORE, &cred);
244 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
245
246 free(cred.credData.data);
247 }
248
249 /**
250 * @tc.name: CmCommonPermissionTest013
251 * @tc.desc: test CmGetUserCertList
252 * @tc.type: FUNC
253 * @tc.require: AR000H0MIA /SR000H09NA
254 */
255 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest013, TestSize.Level0)
256 {
257 struct CertList *certList = nullptr;
258 int32_t ret = InitCertList(&certList);
259 ASSERT_EQ(ret, CM_SUCCESS);
260
261 ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, certList);
262 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
263
264 FreeCertList(certList);
265 }
266
267 /**
268 * @tc.name: CmCommonPermissionTest014
269 * @tc.desc: test CmGetUserCertInfo
270 * @tc.type: FUNC
271 * @tc.require: AR000H0MIA /SR000H09NA
272 */
273 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest014, TestSize.Level0)
274 {
275 struct CertInfo info;
276 (void)memset_s(&info, sizeof(struct CertInfo), 0, sizeof(struct CertInfo));
277 int32_t ret = InitCertInfo(&info);
278 ASSERT_EQ(ret, CM_SUCCESS);
279
280 uint8_t uriData[] = "Common014";
281 struct CmBlob uri = { sizeof(uriData), uriData };
282 ret = CmGetUserCertInfo(&uri, CM_USER_TRUSTED_STORE, &info);
283 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
284
285 FreeCMBlobData(&info.certInfo);
286 }
287
288 /**
289 * @tc.name: CmCommonPermissionTest015
290 * @tc.desc: test CmSetUserCertStatus
291 * @tc.type: FUNC
292 * @tc.require: AR000H0MIA /SR000H09NA
293 */
294 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest015, TestSize.Level0)
295 {
296 uint8_t uriData[] = "common015";
297 struct CmBlob uri = { sizeof(uriData), uriData };
298 int32_t ret = CmSetUserCertStatus(&uri, CM_USER_TRUSTED_STORE, false);
299 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
300 }
301
302 /**
303 * @tc.name: CmCommonPermissionTest016
304 * @tc.desc: test CmInstallUserTrustedCert
305 * @tc.type: FUNC
306 * @tc.require: AR000H0MIA /SR000H09NA
307 */
308 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest016, TestSize.Level0)
309 {
310 uint8_t certData[] = "common016";
311 struct CmBlob userCert = { sizeof(certData), certData };
312 uint8_t aliasData[] = "common016";
313 struct CmBlob certAlias = { sizeof(aliasData), aliasData };
314 uint8_t uriData[] = "common016";
315 struct CmBlob certUri = { sizeof(uriData), uriData };
316
317 int32_t ret = CmInstallUserTrustedCert(&userCert, &certAlias, &certUri);
318 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
319 }
320
321 /**
322 * @tc.name: CmCommonPermissionTest017
323 * @tc.desc: test CmUninstallUserTrustedCert
324 * @tc.type: FUNC
325 * @tc.require: AR000H0MIA /SR000H09NA
326 */
327 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest017, TestSize.Level0)
328 {
329 uint8_t uriData[] = "common017";
330 struct CmBlob certUri = { sizeof(uriData), uriData };
331
332 int32_t ret = CmUninstallUserTrustedCert(&certUri);
333 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
334 }
335
336 /**
337 * @tc.name: CmCommonPermissionTest018
338 * @tc.desc: test CmUninstallAllUserTrustedCert
339 * @tc.type: FUNC
340 * @tc.require: AR000H0MIA /SR000H09NA
341 */
342 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest018, TestSize.Level0)
343 {
344 int32_t ret = CmUninstallAllUserTrustedCert();
345 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
346 }
347
348 /**
349 * @tc.name: CmCommonPermissionTest019
350 * @tc.desc: test CmGrantAppCertificate
351 * @tc.type: FUNC
352 * @tc.require: AR000H0MIA /SR000H09NA
353 */
354 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest019, TestSize.Level0)
355 {
356 uint8_t uriData[] = "common019";
357 struct CmBlob uri = { sizeof(uriData), uriData };
358 uint8_t authUriData[] = "common019";
359 struct CmBlob authUri = { sizeof(authUriData), authUriData };
360
361 int32_t ret = CmGrantAppCertificate(&uri, 0, &authUri);
362 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
363 }
364
365 /**
366 * @tc.name: CmCommonPermissionTest020
367 * @tc.desc: test CmGetAuthorizedAppList
368 * @tc.type: FUNC
369 * @tc.require: AR000H0MIA /SR000H09NA
370 */
371 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest020, TestSize.Level0)
372 {
373 uint8_t uriData[] = "common019";
374 struct CmBlob uri = { sizeof(uriData), uriData };
375 struct CmAppUidList appUidList = { 0, nullptr };
376 int32_t ret = CmGetAuthorizedAppList(&uri, &appUidList);
377 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
378 }
379
380 /**
381 * @tc.name: CmCommonPermissionTest021
382 * @tc.desc: test CmIsAuthorizedApp
383 * @tc.type: FUNC
384 * @tc.require: AR000H0MIA /SR000H09NA
385 */
386 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest021, TestSize.Level0)
387 {
388 uint8_t uriData[] = "common020";
389 struct CmBlob uri = { sizeof(uriData), uriData };
390 int32_t ret = CmIsAuthorizedApp(&uri);
391 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
392 }
393
394 /**
395 * @tc.name: CmCommonPermissionTest022
396 * @tc.desc: test CmRemoveGrantedApp
397 * @tc.type: FUNC
398 * @tc.require: AR000H0MIA /SR000H09NA
399 */
400 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest022, TestSize.Level0)
401 {
402 uint8_t uriData[] = "common021";
403 struct CmBlob uri = { sizeof(uriData), uriData };
404 int32_t ret = CmRemoveGrantedApp(&uri, 0);
405 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
406 }
407
408 /**
409 * @tc.name: CmCommonPermissionTest023
410 * @tc.desc: test init
411 * @tc.type: FUNC
412 * @tc.require: AR000H0MIA /SR000H09NA
413 */
414 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest023, TestSize.Level0)
415 {
416 uint8_t uriData[] = "common023";
417 struct CmBlob authUri = { sizeof(uriData), uriData };
418 uint8_t handleValue[] = "common023";
419 struct CmBlob handle = { sizeof(handleValue), handleValue };
420 struct CmSignatureSpec spec = { CM_KEY_PURPOSE_SIGN, CM_PADDING_NONE, CM_DIGEST_SHA256 };
421
422 int32_t ret = CmInit(&authUri, &spec, &handle);
423 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
424 }
425
426 /**
427 * @tc.name: CmCommonPermissionTest024
428 * @tc.desc: test update
429 * @tc.type: FUNC
430 * @tc.require: AR000H0MIA /SR000H09NA
431 */
432 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest024, TestSize.Level0)
433 {
434 uint8_t handleValue[] = "common024";
435 struct CmBlob handle = { sizeof(handleValue), handleValue };
436 uint8_t inDataBuf[] = "common024";
437 struct CmBlob inData = { sizeof(inDataBuf), inDataBuf };
438
439 int32_t ret = CmUpdate(&handle, &inData);
440 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
441 }
442
443 /**
444 * @tc.name: CmCommonPermissionTest025
445 * @tc.desc: test finish
446 * @tc.type: FUNC
447 * @tc.require: AR000H0MIA /SR000H09NA
448 */
449 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest025, TestSize.Level0)
450 {
451 uint8_t handleValue[] = "common025";
452 struct CmBlob handle = { sizeof(handleValue), handleValue };
453 uint8_t inDataBuf[] = "common025";
454 struct CmBlob inData = { sizeof(inDataBuf), inDataBuf };
455 uint8_t outDataBuf[] = "common025";
456 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
457
458 int32_t ret = CmFinish(&handle, &inData, &outData);
459 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
460 }
461
462 /**
463 * @tc.name: CmCommonPermissionTest026
464 * @tc.desc: test abort
465 * @tc.type: FUNC
466 * @tc.require: AR000H0MIA /SR000H09NA
467 */
468 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest026, TestSize.Level0)
469 {
470 uint8_t handleValue[] = "common026";
471 struct CmBlob handle = { sizeof(handleValue), handleValue };
472 int32_t ret = CmAbort(&handle);
473 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
474 }
475
476 /**
477 * @tc.name: CmCommonPermissionTest027
478 * @tc.desc: test CmInstallAppCert sys credential
479 * @tc.type: FUNC
480 * @tc.require: AR000H0MIA /SR000H09NA
481 */
482 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest027, TestSize.Level0)
483 {
484 uint8_t aliasData[] = "Common027";
485 struct CmBlob alias = { sizeof(aliasData), aliasData };
486 int32_t ret = TestGenerateAppCert(&alias, CERT_KEY_ALG_RSA, CM_SYS_CREDENTIAL_STORE);
487 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
488 }
489
490 /**
491 * @tc.name: CmCommonPermissionTest028
492 * @tc.desc: test CmUninstallAppCert sys credential
493 * @tc.type: FUNC
494 * @tc.require: AR000H0MIA /SR000H09NA
495 */
496 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest028, TestSize.Level0)
497 {
498 uint8_t uriData[] = "Common028";
499 struct CmBlob uri = { sizeof(uriData), uriData };
500 int32_t ret = CmUninstallAppCert(&uri, CM_SYS_CREDENTIAL_STORE);
501 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
502 }
503
504 /**
505 * @tc.name: CmCommonPermissionTest029
506 * @tc.desc: test CmGetAppCertList sys
507 * @tc.type: FUNC
508 * @tc.require: AR000H0MIA /SR000H09NA
509 */
510 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest029, TestSize.Level0)
511 {
512 struct CredentialAbstract abstract[MAX_COUNT_CERTIFICATE];
513 (void)memset_s(abstract, sizeof(abstract), 0, sizeof(abstract));
514 struct CredentialList certList = { MAX_COUNT_CERTIFICATE, abstract };
515 int32_t ret = CmGetAppCertList(CM_SYS_CREDENTIAL_STORE, &certList);
516 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
517 }
518
519 /**
520 * @tc.name: CmCommonPermissionTest030
521 * @tc.desc: test CmGetAppCert sys
522 * @tc.type: FUNC
523 * @tc.require: AR000H0MIA /SR000H09NA
524 */
525 HWTEST_F(CmCommonPermissionTest, CmCommonPermissionTest030, TestSize.Level0)
526 {
527 struct Credential cred;
528 (void)memset_s(&cred, sizeof(struct Credential), 0, sizeof(struct Credential));
529 cred.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
530 cred.credData.data = static_cast<uint8_t *>(malloc(MAX_LEN_CERTIFICATE_CHAIN));
531 ASSERT_TRUE(cred.credData.data != nullptr);
532
533 uint8_t uriData[] = "Common030";
534 struct CmBlob uri = { sizeof(uriData), uriData };
535
536 int32_t ret = CmGetAppCert(&uri, CM_SYS_CREDENTIAL_STORE, &cred);
537 EXPECT_EQ(ret, CMR_ERROR_PERMISSION_DENIED);
538
539 free(cred.credData.data);
540 }
541 } // end of namespace
542
543