1 /*
2 * Copyright (c) 2024 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 "cert_manager_api.h"
19 #include "cm_cert_data_ecc.h"
20 #include "cm_cert_data_part1_rsa.h"
21 #include "cm_cert_data_part3_rsa.h"
22 #include "cm_mem.h"
23 #include "cm_test_common.h"
24
25 #define TEST_USERID 100
26
27 using namespace testing::ext;
28 using namespace CertmanagerTest;
29 namespace {
30
31 static const struct CmBlob g_appCert = { sizeof(g_rsa2048P12CertInfo), const_cast<uint8_t *>(g_rsa2048P12CertInfo) };
32 static const struct CmBlob g_eccAppCert = { sizeof(g_eccP256P12CertInfo), const_cast<uint8_t *>(g_eccP256P12CertInfo) };
33 static const struct CmBlob g_appCertPwd = { sizeof(g_certPwd), const_cast<uint8_t *>(g_certPwd) };
34
35 static const uint8_t g_abnormalCertData[] = {
36 0x30, 0x82, 0x0b, 0xc1, 0x02, 0x01, 0x03, 0xf7, 0x0d, 0x01, 0x07, 0x06, 0x09, 0x2a, 0x86, 0x48,
37 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0xa0, 0x82, 0x0b, 0x78, 0x04, 0x82, 0x0b, 0x74, 0x30, 0x82,
38 0x00, 0x3a, 0x69, 0x16, 0xe1, 0x63, 0x0c, 0xe5, 0x92, 0xc2, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07,
39 0x06, 0xa0, 0x82, 0x06, 0x18, 0x30, 0x82, 0x06, 0x14, 0x02, 0x01, 0x00, 0x30, 0x82, 0x06, 0x0d,
40 0x06, 0x09, 0x0b, 0x74, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0x30, 0x1c, 0x06, 0x0a, 0x2a,
41 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x0c, 0x01
42 };
43
44 class CmPriAppCertTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47
48 static void TearDownTestCase(void);
49
50 void SetUp();
51
52 void TearDown();
53 };
54
SetUpTestCase(void)55 void CmPriAppCertTest::SetUpTestCase(void)
56 {
57 SetATPermission();
58 }
59
TearDownTestCase(void)60 void CmPriAppCertTest::TearDownTestCase(void)
61 {
62 }
63
SetUp()64 void CmPriAppCertTest::SetUp()
65 {
66 }
67
TearDown()68 void CmPriAppCertTest::TearDown()
69 {
70 }
71
72 /**
73 * @tc.name: PriAppCertTest001
74 * @tc.desc: Test CertManager Install private app cert interface base function
75 * @tc.type: FUNC
76 */
77 HWTEST_F(CmPriAppCertTest, PriAppCertTest001, TestSize.Level0)
78 {
79 char retUriBuf[MAX_LEN_URI] = {0};
80 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
81
82 uint8_t certAliasBuf[] = "PrikeyA";
83 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
84 uint8_t certAliasBuf001[] = "PrikeyB";
85 struct CmBlob certAlias01 = { sizeof(certAliasBuf001), certAliasBuf001 };
86
87 /* test g_appCert */
88 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
89 &certAlias, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
90 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
91 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest001 1 credentail test failed, retcode:" << ret;
92
93 char uriBuf[] = "oh:t=ak;o=PrikeyA;u=0;a=0";
94 EXPECT_EQ(strcmp(uriBuf, (char *)priKeyUri.data), 0) << "strcmp failed, uri: %s" << (char *)priKeyUri.data;
95
96 /* test g_eccAppCert, level=el1 */
97 struct CmAppCertParam appCertParam01 = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
98 &certAlias01, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
99 ret = CmInstallAppCertEx(&appCertParam01, &priKeyUri);
100 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest001 2 credentail test failed, retcode:" << ret;
101
102 char uriBuf001[] = "oh:t=ak;o=PrikeyB;u=0;a=0";
103 EXPECT_EQ(strcmp(uriBuf001, (char *)priKeyUri.data), 0) << "strcmp failed";
104
105 ret = CmUninstallAllAppCert();
106 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest001 test failed, retcode:" << ret;
107 }
108
109 /**
110 * @tc.name: PriAppCertTest002
111 * @tc.desc: Test CertManager Install private app cert interface base function
112 * @tc.type: FUNC
113 */
114 HWTEST_F(CmPriAppCertTest, PriAppCertTest002, TestSize.Level0)
115 {
116 char retUriBuf[MAX_LEN_URI] = {0};
117 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
118
119 uint8_t certAliasBuf[] = "PrikeyA";
120 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
121 uint8_t certAliasBuf002[] = "PrikeyB";
122 struct CmBlob certAlias02 = { sizeof(certAliasBuf002), certAliasBuf002 };
123
124 /* test g_appCert,level=el2 */
125 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
126 &certAlias, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL2 };
127 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
128 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest002 1 credentail test failed, retcode:" << ret;
129
130 char uriBuf[] = "oh:t=ak;o=PrikeyA;u=0;a=0";
131 EXPECT_EQ(strcmp(uriBuf, (char *)priKeyUri.data), 0) << "strcmp failed";
132
133 /* test g_eccAppCert */
134 struct CmAppCertParam appCertParam01 = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
135 &certAlias02, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL2 };
136 ret = CmInstallAppCertEx(&appCertParam01, &priKeyUri);
137 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest002 2 credentail test failed, retcode:" << ret;
138
139 char uriBuf001[] = "oh:t=ak;o=PrikeyB;u=0;a=0";
140 EXPECT_EQ(strcmp(uriBuf001, (char *)priKeyUri.data), 0) << "strcmp failed";
141
142 ret = CmUninstallAllAppCert();
143 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest002 test failed, retcode:" << ret;
144 }
145
146 /**
147 * @tc.name: PriAppCertTest003
148 * @tc.desc: Test CertManager Install private app cert interface base function
149 * @tc.type: FUNC
150 */
151 HWTEST_F(CmPriAppCertTest, PriAppCertTest003, TestSize.Level0)
152 {
153 char retUriBuf[MAX_LEN_URI] = {0};
154 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
155
156 uint8_t certAliasBuf[] = "PrikeyA";
157 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
158 uint8_t certAliasBuf003[] = "PrikeyB";
159 struct CmBlob certAlias03 = { sizeof(certAliasBuf003), certAliasBuf003 };
160
161 /* test g_appCert, level=el4 */
162 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
163 &certAlias, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL4 };
164 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
165 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest003 credentail test failed, retcode:" << ret;
166
167 char uriBuf[] = "oh:t=ak;o=PrikeyA;u=0;a=0";
168 EXPECT_EQ(strcmp(uriBuf, (char *)priKeyUri.data), 0) << "strcmp failed";
169
170 /* test g_eccAppCert, level=el4 */
171 struct CmAppCertParam appCertParam01 = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
172 &certAlias03, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL4 };
173 ret = CmInstallAppCertEx(&appCertParam01, &priKeyUri);
174 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest002 2 credentail test failed, retcode:" << ret;
175
176 char uriBuf001[] = "oh:t=ak;o=PrikeyB;u=0;a=0";
177 EXPECT_EQ(strcmp(uriBuf001, (char *)priKeyUri.data), 0) << "strcmp failed";
178
179 ret = CmUninstallAllAppCert();
180 EXPECT_EQ(ret, CM_SUCCESS) << "PriAppCertTest003 test failed, retcode:" << ret;
181 }
182
183 /**
184 * @tc.name: PriAppCertTest004
185 * @tc.desc: Test Install private app cert abnormal function
186 * @tc.type: FUNC
187 */
188 HWTEST_F(CmPriAppCertTest, PriAppCertTest004, TestSize.Level0)
189 {
190 char retUriBuf[MAX_LEN_URI] = {0};
191 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
192
193 uint8_t certAliasBuf[] = "PrikeyA";
194 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
195
196 /* level is invalid */
197 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
198 &certAlias, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, static_cast<CmAuthStorageLevel>(ERROR_LEVEL) };
199 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
200 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest004 credentail test failed, retcode:" << ret;
201 }
202
203 /**
204 * @tc.name: PriAppCertTest005
205 * @tc.desc: Test Install private app cert abnormal function
206 * @tc.type: FUNC
207 */
208 HWTEST_F(CmPriAppCertTest, PriAppCertTest005, TestSize.Level0)
209 {
210 char retUriBuf[MAX_LEN_URI] = {0};
211 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
212
213 uint8_t certAliasBuf[] = "PrikeyA";
214 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
215
216 /* store is not private cred */
217 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
218 &certAlias, CM_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
219 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
220 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest005 credentail test failed, retcode:" << ret;
221 }
222
223 /**
224 * @tc.name: PriAppCertTest006
225 * @tc.desc: Test Install private app cert abnormal function
226 * @tc.type: FUNC
227 */
228 HWTEST_F(CmPriAppCertTest, PriAppCertTest006, TestSize.Level0)
229 {
230 char retUriBuf[MAX_LEN_URI] = {0};
231 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
232
233 uint8_t certAliasBuf[] = "PrikeyA";
234 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
235
236 /* pri app cert data is abnormal */
237 struct CmBlob abnormalAppCert = { sizeof(g_abnormalCertData), const_cast<uint8_t *>(g_abnormalCertData) };
238
239 struct CmAppCertParam appCertParam = { &abnormalAppCert, (struct CmBlob *)&g_appCertPwd,
240 &certAlias, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
241 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
242 EXPECT_EQ(ret, CMR_ERROR_INVALID_CERT_FORMAT) << "PriAppCertTest006 credentail test failed, retcode:" << ret;
243 }
244
245 /**
246 * @tc.name: PriAppCertTest007
247 * @tc.desc: Test CertManager Install private app cert interface abnormal function
248 * @tc.type: FUNC
249 */
250 HWTEST_F(CmPriAppCertTest, PriAppCertTest007, TestSize.Level0)
251 {
252 char retUriBuf[MAX_LEN_URI] = {0};
253 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
254
255 /* certParam is nullptr */
256 int32_t ret = CmInstallAppCertEx(nullptr, &priKeyUri);
257 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest007 credentail test failed, retcode:" << ret;
258 }
259
260 /**
261 * @tc.name: PriAppCertTest008
262 * @tc.desc: Test CertManager Install private app cert interface abnormal function
263 * @tc.type: FUNC
264 */
265 HWTEST_F(CmPriAppCertTest, PriAppCertTest008, TestSize.Level0)
266 {
267 char retUriBuf[MAX_LEN_URI] = {0};
268 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
269
270 uint8_t certAliasBuf[] = "PriAppCertTest008";
271 struct CmBlob certAlias007 = { sizeof(certAliasBuf), certAliasBuf };
272
273 /* certParam->appCert is nullptr */
274 struct CmAppCertParam appCertParam = { nullptr, (struct CmBlob *)&g_appCertPwd,
275 &certAlias007, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
276 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
277 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest008 credentail test failed, retcode:" << ret;
278 }
279
280 /**
281 * @tc.name: PriAppCertTest009
282 * @tc.desc: Test CertManager Install private app cert interface abnormal function
283 * @tc.type: FUNC
284 */
285 HWTEST_F(CmPriAppCertTest, PriAppCertTest009, TestSize.Level0)
286 {
287 char retUriBuf[MAX_LEN_URI] = {0};
288 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
289
290 uint8_t certAliasBuf[] = "PriAppCertTest009";
291 struct CmBlob certAlias008 = { sizeof(certAliasBuf), certAliasBuf };
292
293 /* certParam->appCertPwd is nullptr */
294 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, nullptr,
295 &certAlias008, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
296 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
297 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest009 credentail test failed, retcode:" << ret;
298 }
299
300 /**
301 * @tc.name: PriAppCertTest010
302 * @tc.desc: Test CertManager Install private app cert interface abnormal function
303 * @tc.type: FUNC
304 */
305 HWTEST_F(CmPriAppCertTest, PriAppCertTest010, TestSize.Level0)
306 {
307 char retUriBuf[MAX_LEN_URI] = {0};
308 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
309
310 /* certParam->certAlias is nullptr */
311 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
312 nullptr, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
313 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
314 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest010 credentail test failed, retcode:" << ret;
315 }
316
317 /**
318 * @tc.name: PriAppCertTest011
319 * @tc.desc: Test CertManager Install private app cert interface abnormal function
320 * @tc.type: FUNC
321 */
322 HWTEST_F(CmPriAppCertTest, PriAppCertTest011, TestSize.Level0)
323 {
324 uint8_t certAliasBuf[] = "PriAppCertTest011";
325 struct CmBlob certAlias010 = { sizeof(certAliasBuf), certAliasBuf };
326 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
327 &certAlias010, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
328
329 /* keyUri is nullptr */
330 int32_t ret = CmInstallAppCertEx(&appCertParam, nullptr);
331 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest011 credentail test failed, retcode:" << ret;
332 }
333
334 /**
335 * @tc.name: PriAppCertTest012
336 * @tc.desc: Test CertManager Install private app cert interface abnormal function
337 * @tc.type: FUNC
338 */
339 HWTEST_F(CmPriAppCertTest, PriAppCertTest012, TestSize.Level0)
340 {
341 struct CmBlob priKeyUri = { 0, nullptr };
342 uint8_t certAliasBuf[] = "PriAppCertTest012";
343 struct CmBlob certAlias010 = { sizeof(certAliasBuf), certAliasBuf };
344 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
345 &certAlias010, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
346
347 /* keyUri->data is nullptr */
348 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
349 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest012 credentail test failed, retcode:" << ret;
350 }
351
352 /**
353 * @tc.name: PriAppCertTest013
354 * @tc.desc: Test CertManager Install private app cert interface abnormal function
355 * @tc.type: FUNC
356 */
357 HWTEST_F(CmPriAppCertTest, PriAppCertTest013, TestSize.Level0)
358 {
359 char retUriBuf[MAX_LEN_URI] = {0};
360 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
361
362 /* certAlias not include '\0' */
363 uint8_t certAliasBuf[] = "PrikeyB";
364 struct CmBlob certAlias013 = { sizeof(certAliasBuf) - 1, certAliasBuf };
365
366 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
367 &certAlias013, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
368 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
369 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest013 credentail test failed, retcode:" << ret;
370 }
371
372 /**
373 * @tc.name: PriAppCertTest014
374 * @tc.desc: Test CertManager Install private app cert interface abnormal function
375 * @tc.type: FUNC
376 */
377 HWTEST_F(CmPriAppCertTest, PriAppCertTest014, TestSize.Level0)
378 {
379 char retUriBuf[MAX_LEN_URI] = {0};
380 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
381 uint8_t certAliasBuf[] = "PrikeyB";
382 struct CmBlob certAlias014 = { sizeof(certAliasBuf), certAliasBuf };
383
384 /* cert pwd not include '\0' */
385 uint8_t errPwdBuf[] = "123789";
386 struct CmBlob errPwd = { sizeof(errPwdBuf) - 1, errPwdBuf };
387
388 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &errPwd,
389 &certAlias014, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
390 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
391 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest014 credentail test failed, retcode:" << ret;
392 }
393
394 /**
395 * @tc.name: PriAppCertTest015
396 * @tc.desc: Test CertManager Install private app cert interface abnormal function
397 * @tc.type: FUNC
398 */
399 HWTEST_F(CmPriAppCertTest, PriAppCertTest015, TestSize.Level0)
400 {
401 char retUriBuf[MAX_LEN_URI] = {0};
402 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
403
404 /* certAlias data is nullptr */
405 uint8_t certAliasBuf[] = "PrikeyB";
406 struct CmBlob certAlias015 = { sizeof(certAliasBuf), nullptr };
407
408 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
409 &certAlias015, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
410 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
411 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest015 credentail test failed, retcode:" << ret;
412 }
413
414 /**
415 * @tc.name: PriAppCertTest016
416 * @tc.desc: Test CertManager Install private app cert interface abnormal function
417 * @tc.type: FUNC
418 */
419 HWTEST_F(CmPriAppCertTest, PriAppCertTest016, TestSize.Level0)
420 {
421 char retUriBuf[MAX_LEN_URI] = {0};
422 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
423
424 /* certAlias size is 0 */
425 uint8_t certAliasBuf[] = "PrikeyB";
426 struct CmBlob certAlias016 = { 0, certAliasBuf };
427
428 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
429 &certAlias016, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
430 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
431 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest016 credentail test failed, retcode:" << ret;
432 }
433
434 /**
435 * @tc.name: PriAppCertTest017
436 * @tc.desc: Test CertManager Install private app cert interface abnormal function
437 * @tc.type: FUNC
438 */
439 HWTEST_F(CmPriAppCertTest, PriAppCertTest017, TestSize.Level0)
440 {
441 char retUriBuf[MAX_LEN_URI] = {0};
442 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
443
444 /* certAlias size beyond max */
445 uint8_t certAliasBuf[] = "123456789012345678901234567890123456789012345678901234567890 \
446 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";
447 struct CmBlob certAlias018 = { sizeof(certAliasBuf), certAliasBuf };
448
449 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
450 &certAlias018, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
451 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
452 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) <<
453 "PriAppCertTest017 credentail test failed, retcode:" << ret;
454 }
455
456 /**
457 * @tc.name: PriAppCertTest018
458 * @tc.desc: Test CertManager Install private app cert interface abnormal function
459 * @tc.type: FUNC
460 */
461 HWTEST_F(CmPriAppCertTest, PriAppCertTest018, TestSize.Level0)
462 {
463 char retUriBuf[MAX_LEN_URI] = {0};
464 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
465 uint8_t certAliasBuf[] = "PrikeyB";
466 struct CmBlob certAlias019 = { sizeof(certAliasBuf), certAliasBuf };
467
468 /* appCert data is nullptr */
469 struct CmBlob appCert = { sizeof(g_rsa2048P12CertInfo), nullptr };
470
471 struct CmAppCertParam appCertParam = { &appCert, (struct CmBlob *)&g_appCertPwd,
472 &certAlias019, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
473 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
474 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest018 credentail test failed, retcode:" << ret;
475 }
476
477 /**
478 * @tc.name: PriAppCertTest019
479 * @tc.desc: Test CertManager Install private app cert interface abnormal function
480 * @tc.type: FUNC
481 */
482 HWTEST_F(CmPriAppCertTest, PriAppCertTest019, TestSize.Level0)
483 {
484 char retUriBuf[MAX_LEN_URI] = {0};
485 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
486 uint8_t certAliasBuf[] = "PrikeyB";
487 struct CmBlob certAlias019 = { sizeof(certAliasBuf), certAliasBuf };
488
489 /* appCert size is 0 */
490 struct CmBlob appCert = { 0, const_cast<uint8_t *>(g_rsa2048P12CertInfo) };
491
492 struct CmAppCertParam appCertParam = { &appCert, (struct CmBlob *)&g_appCertPwd,
493 &certAlias019, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
494 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
495 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest019 credentail test failed, retcode:" << ret;
496 }
497
498 /**
499 * @tc.name: PriAppCertTest020
500 * @tc.desc: Test CertManager Install private app cert interface abnormal function
501 * @tc.type: FUNC
502 */
503 HWTEST_F(CmPriAppCertTest, PriAppCertTest020, TestSize.Level0)
504 {
505 char retUriBuf[MAX_LEN_URI] = {0};
506 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
507 uint8_t certAliasBuf[] = "PrikeyB";
508 struct CmBlob certAlias019 = { sizeof(certAliasBuf), certAliasBuf };
509
510 /* appCert size beyond max */
511 uint8_t appCertData[MAX_LEN_APP_CERT + 1] = { 0 };
512 struct CmBlob appCert = { MAX_LEN_APP_CERT + 1, appCertData };
513
514 struct CmAppCertParam appCertParam = { &appCert, (struct CmBlob *)&g_appCertPwd,
515 &certAlias019, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
516 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
517 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest020 credentail test failed, retcode:" << ret;
518 }
519
520 /**
521 * @tc.name: PriAppCertTest021
522 * @tc.desc: Test CertManager Install private app cert interface abnormal function
523 * @tc.type: FUNC
524 */
525 HWTEST_F(CmPriAppCertTest, PriAppCertTest021, TestSize.Level0)
526 {
527 char retUriBuf[MAX_LEN_URI] = {0};
528 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
529 uint8_t certAliasBuf[] = "PrikeyB";
530 struct CmBlob certAlias020 = { sizeof(certAliasBuf), certAliasBuf };
531
532 /* appCertPwd->data is nullptr */
533 uint8_t pwdBuf[] = "123789";
534 struct CmBlob appCertPwd = { sizeof(pwdBuf), nullptr };
535
536 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &appCertPwd,
537 &certAlias020, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
538 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
539 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest021 credentail test failed, retcode:" << ret;
540 }
541
542 /**
543 * @tc.name: PriAppCertTest022
544 * @tc.desc: Test CertManager Install private app cert interface abnormal function
545 * @tc.type: FUNC
546 */
547 HWTEST_F(CmPriAppCertTest, PriAppCertTest022, TestSize.Level0)
548 {
549 char retUriBuf[MAX_LEN_URI] = {0};
550 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
551 uint8_t certAliasBuf[] = "PrikeyB";
552 struct CmBlob certAlias021 = { sizeof(certAliasBuf), certAliasBuf };
553
554 /* appCertPwd->size is 0 */
555 uint8_t pwdBuf[] = "123789";
556 struct CmBlob appCertPwd = { 0, pwdBuf };
557
558 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &appCertPwd,
559 &certAlias021, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
560 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
561 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest022 credentail test failed, retcode:" << ret;
562 }
563
564 /**
565 * @tc.name: PriAppCertTest023
566 * @tc.desc: Test CertManager Install private app cert interface abnormal function
567 * @tc.type: FUNC
568 */
569 HWTEST_F(CmPriAppCertTest, PriAppCertTest023, TestSize.Level0)
570 {
571 char retUriBuf[MAX_LEN_URI] = {0};
572 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
573 uint8_t certAliasBuf[] = "PrikeyB";
574 struct CmBlob certAlias022 = { sizeof(certAliasBuf), certAliasBuf };
575
576 /* appCertPwd->size beyond max */
577 uint8_t pwdBuf[] = "123456789012345678901234567890123456";
578 struct CmBlob appCertPwd = { sizeof(pwdBuf), pwdBuf };
579
580 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &appCertPwd,
581 &certAlias022, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
582 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
583 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest023 credentail test failed, retcode:" << ret;
584 }
585
586 /**
587 * @tc.name: PriAppCertTest024
588 * @tc.desc: Test CertManager Install private app cert interface abnormal function
589 * @tc.type: FUNC
590 */
591 HWTEST_F(CmPriAppCertTest, PriAppCertTest024, TestSize.Level0)
592 {
593 char retUriBuf[MAX_LEN_URI] = {0};
594 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
595
596 uint8_t certAliasBuf[] = "PrikeyA";
597 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
598
599 /* err password */
600 uint8_t appCertPwdBuf[] = "123456789";
601 struct CmBlob errAppCertPwd = { sizeof(appCertPwdBuf), appCertPwdBuf };
602
603 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, &errAppCertPwd,
604 &certAlias, CM_PRI_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL1 };
605 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
606 EXPECT_EQ(ret, CMR_ERROR_PASSWORD_IS_ERR) << "PriAppCertTest024 credentail test failed, retcode:" << ret;
607 }
608
609 /**
610 * @tc.name: PriAppCertTest025
611 * @tc.desc: Test CertManager Install private app cert interface abnormal function
612 * @tc.type: FUNC
613 */
614 HWTEST_F(CmPriAppCertTest, PriAppCertTest025, TestSize.Level0)
615 {
616 char retUriBuf[MAX_LEN_URI] = {0};
617 struct CmBlob priKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
618
619 uint8_t certAliasBuf[] = "PrikeyA";
620 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
621
622 /* userid is not invalid */
623 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
624 &certAlias, CM_PRI_CREDENTIAL_STORE, TEST_USERID, CM_AUTH_STORAGE_LEVEL_EL1 };
625 int32_t ret = CmInstallAppCertEx(&appCertParam, &priKeyUri);
626 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "PriAppCertTest025 1 credentail test failed, retcode:" << ret;
627 }
628 }