1 /*
2 * Copyright (c) 2025 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 "identityservice_fuzzer.h"
17
18 #include <cinttypes>
19 #include <unistd.h>
20 #include "alg_loader.h"
21 #include "common_defs.h"
22 #include "device_auth.h"
23 #include "device_auth_defines.h"
24 #include "device_auth_ext.h"
25 #include "hc_dev_info_mock.h"
26 #include "json_utils_mock.h"
27 #include "json_utils.h"
28 #include "protocol_task_main_mock.h"
29 #include "securec.h"
30 #include "hc_file.h"
31 #include <dirent.h>
32 #include <fcntl.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include "hc_log.h"
36 #include "hc_types.h"
37
38 namespace OHOS {
39 #define TEST_RESULT_SUCCESS 0
40 #define TEST_APP_ID "TestAppId"
41 #define TEST_APP_ID1 "TestAppId1"
42 #define TEST_DEVICE_ID "TestDeviceId"
43 #define QUERY_RESULT_NUM 0
44 #define QUERY_RESULT_NUM_2 2
45
46 #define TEST_CRED_DATA_PATH "/data/service/el1/public/deviceauthMock/hccredential.dat"
47
48 static const char *ADD_PARAMS =
49 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
50 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
51 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
52 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
53 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
54 static const char *ADD_PARAMS1 =
55 "{\"credType\":0,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
56 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
57 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
58 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
59 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
60 static const char *ADD_PARAMS2 =
61 "{\"credType\":1,\"keyFormat\":0,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
62 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
63 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
64 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
65 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
66 static const char *ADD_PARAMS3 =
67 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":0,\"subject\":1,\"issuer\":1,"
68 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
69 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
70 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
71 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
72 static const char *ADD_PARAMS4 =
73 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":0,\"issuer\":1,"
74 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
75 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
76 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
77 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
78 static const char *ADD_PARAMS5 =
79 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":0,"
80 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
81 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
82 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
83 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
84 static const char *ADD_PARAMS6 =
85 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
86 "\"proofType\":0,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
87 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
88 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
89 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
90 static const char *ADD_PARAMS7 =
91 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
92 "\"proofType\":1,\"method\":0,\"authorizedScope\":1,\"userId\":\"TestUserId\","
93 "\"keyValue\":\"TestKeyValue\",\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
94 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
95 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
96 static const char *ADD_PARAMS8 =
97 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
98 "\"proofType\":1,\"method\":1,\"authorizedScope\":0,\"userId\":\"TestUserId\","
99 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
100 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
101 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
102 static const char *ADD_PARAMS9 =
103 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
104 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
105 "\"credOwner\":\"TestAppId\","
106 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
107 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
108 static const char *ADD_PARAMS10 =
109 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
110 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
111 "\"deviceId\":\"TestDeviceId\","
112 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
113 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
114 static const char *ADD_PARAMS11 =
115 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
116 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,"
117 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
118 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
119 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
120 static const char *ADD_PARAMS12 =
121 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
122 "\"proofType\":1,\"method\":2,\"authorizedScope\":1,\"userId\":\"TestUserId\","
123 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
124 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
125 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
126 static const char *ADD_PARAMS13 =
127 "{\"credType\":2,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
128 "\"proofType\":1,\"method\":2,\"authorizedScope\":1,\"userId\":\"TestUserId\","
129 "\"keyValue\":\"9A9A9A9A\",\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
130 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
131 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
132 static const char *ADD_PARAMS14 =
133 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
134 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
135 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId1\","
136 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
137 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
138 static const char *ADD_PARAMS15 =
139 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
140 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
141 "\"keyValue\":\"TestKeyValue\",\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
142 "\"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
143 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
144 static const char *REQUEST_PARAMS =
145 "{\"authorizedScope\":1, \"authorizedAppList\":[\"TestName1\",\"TestName2\",\"TestName3\","
146 "\"TestName4\"],\"extendInfo\":\"\"}";
147
148 static const char *QUERY_PARAMS = "{\"deviceId\":\"TestDeviceId\"}";
149 static const char *QUERY_PARAMS1 = "{\"deviceId\":\"TestDeviceId1\"}";
150
151 enum CredListenerStatus {
152 CRED_LISTENER_INIT = 0,
153 CRED_LISTENER_ON_ADD = 1,
154 CRED_LISTENER_ON_UPDATE = 2,
155 CRED_LISTENER_ON_DELETE = 3,
156 };
157
158 static CredListenerStatus volatile g_credListenerStatus;
159
TestOnCredAdd(const char * credId,const char * credInfo)160 static void TestOnCredAdd(const char *credId, const char *credInfo)
161 {
162 (void)credId;
163 (void)credInfo;
164 g_credListenerStatus = CRED_LISTENER_ON_ADD;
165 }
166
TestOnCredUpdate(const char * credId,const char * credInfo)167 static void TestOnCredUpdate(const char *credId, const char *credInfo)
168 {
169 (void)credId;
170 (void)credInfo;
171 g_credListenerStatus = CRED_LISTENER_ON_UPDATE;
172 }
173
TestOnCredDelete(const char * credId,const char * credInfo)174 static void TestOnCredDelete(const char *credId, const char *credInfo)
175 {
176 (void)credId;
177 (void)credInfo;
178 g_credListenerStatus = CRED_LISTENER_ON_DELETE;
179 }
180
181 static CredChangeListener g_credChangeListener = {
182 .onCredAdd = TestOnCredAdd,
183 .onCredUpdate = TestOnCredUpdate,
184 .onCredDelete = TestOnCredDelete,
185 };
186
DeleteDatabase()187 static void DeleteDatabase()
188 {
189 HcFileRemove(TEST_CRED_DATA_PATH);
190 }
191
IdentityServiceTestCase001(void)192 static int32_t IdentityServiceTestCase001(void)
193 {
194 DeleteDatabase();
195 int32_t ret = InitDeviceAuthService();
196 if (ret != HC_SUCCESS) {
197 return ret;
198 }
199 do {
200 char *returnData = nullptr;
201 const CredManager *cm = GetCredMgrInstance();
202 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &returnData);
203 HcFree(returnData);
204 } while (0);
205 DestroyDeviceAuthService();
206 return ret;
207 }
208
IdentityServiceTestCase002(void)209 static int32_t IdentityServiceTestCase002(void)
210 {
211 DeleteDatabase();
212 int32_t ret = InitDeviceAuthService();
213 if (ret != HC_SUCCESS) {
214 return ret;
215 }
216 do {
217 char *returnData = nullptr;
218 const CredManager *cm = GetCredMgrInstance();
219 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, nullptr, &returnData);
220 HcFree(returnData);
221 } while (0);
222 DestroyDeviceAuthService();
223 return ret;
224 }
225
IdentityServiceTestCase003(void)226 static int32_t IdentityServiceTestCase003(void)
227 {
228 DeleteDatabase();
229 int32_t ret = InitDeviceAuthService();
230 if (ret != HC_SUCCESS) {
231 return ret;
232 }
233 do {
234 const CredManager *cm = GetCredMgrInstance();
235 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, nullptr);
236 } while (0);
237 DestroyDeviceAuthService();
238 return ret;
239 }
240
IdentityServiceTestCase004(void)241 static int32_t IdentityServiceTestCase004(void)
242 {
243 DeleteDatabase();
244 int32_t ret = InitDeviceAuthService();
245 if (ret != HC_SUCCESS) {
246 return ret;
247 }
248 do {
249 const CredManager *cm = GetCredMgrInstance();
250 char *returnData = nullptr;
251 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS1, &returnData);
252 HcFree(returnData);
253 } while (0);
254 DestroyDeviceAuthService();
255 return ret;
256 }
257
IdentityServiceTestCase005(void)258 static int32_t IdentityServiceTestCase005(void)
259 {
260 DeleteDatabase();
261 int32_t ret = InitDeviceAuthService();
262 if (ret != HC_SUCCESS) {
263 return ret;
264 }
265 do {
266 const CredManager *cm = GetCredMgrInstance();
267 char *returnData = nullptr;
268 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS2, &returnData);
269 HcFree(returnData);
270 } while (0);
271 DestroyDeviceAuthService();
272 return ret;
273 }
274
IdentityServiceTestCase006(void)275 static int32_t IdentityServiceTestCase006(void)
276 {
277 DeleteDatabase();
278 int32_t ret = InitDeviceAuthService();
279 if (ret != HC_SUCCESS) {
280 return ret;
281 }
282 do {
283 const CredManager *cm = GetCredMgrInstance();
284 char *returnData = nullptr;
285 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS3, &returnData);
286 HcFree(returnData);
287 } while (0);
288 DestroyDeviceAuthService();
289 return ret;
290 }
291
IdentityServiceTestCase007(void)292 static int32_t IdentityServiceTestCase007(void)
293 {
294 DeleteDatabase();
295 int32_t ret = InitDeviceAuthService();
296 if (ret != HC_SUCCESS) {
297 return ret;
298 }
299 do {
300 const CredManager *cm = GetCredMgrInstance();
301 char *returnData = nullptr;
302 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS4, &returnData);
303 HcFree(returnData);
304 } while (0);
305 DestroyDeviceAuthService();
306 return ret;
307 }
308
IdentityServiceTestCase008(void)309 static int32_t IdentityServiceTestCase008(void)
310 {
311 DeleteDatabase();
312 int32_t ret = InitDeviceAuthService();
313 if (ret != HC_SUCCESS) {
314 return ret;
315 }
316 do {
317 const CredManager *cm = GetCredMgrInstance();
318 char *returnData = nullptr;
319 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS5, &returnData);
320 HcFree(returnData);
321 } while (0);
322 DestroyDeviceAuthService();
323 return ret;
324 }
325
IdentityServiceTestCase009(void)326 static int32_t IdentityServiceTestCase009(void)
327 {
328 DeleteDatabase();
329 int32_t ret = InitDeviceAuthService();
330 if (ret != HC_SUCCESS) {
331 return ret;
332 }
333 do {
334 const CredManager *cm = GetCredMgrInstance();
335 char *returnData = nullptr;
336 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS6, &returnData);
337 HcFree(returnData);
338 } while (0);
339 DestroyDeviceAuthService();
340 return ret;
341 }
342
IdentityServiceTestCase010(void)343 static int32_t IdentityServiceTestCase010(void)
344 {
345 DeleteDatabase();
346 int32_t ret = InitDeviceAuthService();
347 if (ret != HC_SUCCESS) {
348 return ret;
349 }
350 do {
351 const CredManager *cm = GetCredMgrInstance();
352 char *returnData = nullptr;
353 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS7, &returnData);
354 HcFree(returnData);
355 } while (0);
356 DestroyDeviceAuthService();
357 return ret;
358 }
359
IdentityServiceTestCase011(void)360 static int32_t IdentityServiceTestCase011(void)
361 {
362 DeleteDatabase();
363 int32_t ret = InitDeviceAuthService();
364 if (ret != HC_SUCCESS) {
365 return ret;
366 }
367 do {
368 const CredManager *cm = GetCredMgrInstance();
369 char *returnData = nullptr;
370 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS8, &returnData);
371 HcFree(returnData);
372 } while (0);
373 DestroyDeviceAuthService();
374 return ret;
375 }
376
IdentityServiceTestCase012(void)377 static int32_t IdentityServiceTestCase012(void)
378 {
379 DeleteDatabase();
380 int32_t ret = InitDeviceAuthService();
381 if (ret != HC_SUCCESS) {
382 return ret;
383 }
384 do {
385 const CredManager *cm = GetCredMgrInstance();
386 char *returnData = nullptr;
387 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS9, &returnData);
388 HcFree(returnData);
389 } while (0);
390 DestroyDeviceAuthService();
391 return ret;
392 }
393
IdentityServiceTestCase013(void)394 static int32_t IdentityServiceTestCase013(void)
395 {
396 DeleteDatabase();
397 int32_t ret = InitDeviceAuthService();
398 if (ret != HC_SUCCESS) {
399 return ret;
400 }
401 do {
402 const CredManager *cm = GetCredMgrInstance();
403 char *returnData = nullptr;
404 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS10, &returnData);
405 HcFree(returnData);
406 } while (0);
407 DestroyDeviceAuthService();
408 return ret;
409 }
410
IdentityServiceTestCase014(void)411 static int32_t IdentityServiceTestCase014(void)
412 {
413 DeleteDatabase();
414 int32_t ret = InitDeviceAuthService();
415 if (ret != HC_SUCCESS) {
416 return ret;
417 }
418 do {
419 const CredManager *cm = GetCredMgrInstance();
420 char *returnData = nullptr;
421 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS11, &returnData);
422 HcFree(returnData);
423 } while (0);
424 DestroyDeviceAuthService();
425 return ret;
426 }
427
IdentityServiceTestCase015(void)428 static int32_t IdentityServiceTestCase015(void)
429 {
430 DeleteDatabase();
431 int32_t ret = InitDeviceAuthService();
432 if (ret != HC_SUCCESS) {
433 return ret;
434 }
435 do {
436 const CredManager *cm = GetCredMgrInstance();
437 char *returnData = nullptr;
438 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS12, &returnData);
439 HcFree(returnData);
440 } while (0);
441 DestroyDeviceAuthService();
442 return ret;
443 }
444
IdentityServiceTestCase016(void)445 static int32_t IdentityServiceTestCase016(void)
446 {
447 DeleteDatabase();
448 int32_t ret = InitDeviceAuthService();
449 if (ret != HC_SUCCESS) {
450 return ret;
451 }
452 do {
453 const CredManager *cm = GetCredMgrInstance();
454 char *returnData = nullptr;
455 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS13, &returnData);
456 HcFree(returnData);
457 } while (0);
458 DestroyDeviceAuthService();
459 return ret;
460 }
461
IdentityServiceTestCase048(void)462 static int32_t IdentityServiceTestCase048(void)
463 {
464 DeleteDatabase();
465 int32_t ret = InitDeviceAuthService();
466 if (ret != HC_SUCCESS) {
467 return ret;
468 }
469 do {
470 const CredManager *cm = GetCredMgrInstance();
471 char *returnData = nullptr;
472 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS15, &returnData);
473 HcFree(returnData);
474 } while (0);
475 DestroyDeviceAuthService();
476 return ret;
477 }
478
IdentityServiceTestCase017(void)479 static int32_t IdentityServiceTestCase017(void)
480 {
481 DeleteDatabase();
482 int32_t ret = InitDeviceAuthService();
483 if (ret != HC_SUCCESS) {
484 return ret;
485 }
486 do {
487 const CredManager *cm = GetCredMgrInstance();
488 char *credId = nullptr;
489 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
490 char *returnData = nullptr;
491 ret = cm->exportCredential(DEFAULT_OS_ACCOUNT, credId, &returnData);
492 HcFree(credId);
493 HcFree(returnData);
494 } while (0);
495 DestroyDeviceAuthService();
496 return ret;
497 }
498
IdentityServiceTestCase018(void)499 static int32_t IdentityServiceTestCase018(void)
500 {
501 DeleteDatabase();
502 int32_t ret = InitDeviceAuthService();
503 if (ret != HC_SUCCESS) {
504 return ret;
505 }
506 do {
507 const CredManager *cm = GetCredMgrInstance();
508 char *credId = nullptr;
509 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS2, &credId);
510 char *returnData = nullptr;
511 ret = cm->exportCredential(DEFAULT_OS_ACCOUNT, credId, &returnData);
512 HcFree(credId);
513 HcFree(returnData);
514 } while (0);
515 DestroyDeviceAuthService();
516 return ret;
517 }
518
IdentityServiceTestCase019(void)519 static int32_t IdentityServiceTestCase019(void)
520 {
521 DeleteDatabase();
522 int32_t ret = InitDeviceAuthService();
523 if (ret != HC_SUCCESS) {
524 return ret;
525 }
526 do {
527 const CredManager *cm = GetCredMgrInstance();
528 char *credId = nullptr;
529 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
530 ret = cm->exportCredential(DEFAULT_OS_ACCOUNT, credId, nullptr);
531 HcFree(credId);
532 } while (0);
533 DestroyDeviceAuthService();
534 return ret;
535 }
536
IdentityServiceTestCase020(void)537 static int32_t IdentityServiceTestCase020(void)
538 {
539 DeleteDatabase();
540 int32_t ret = InitDeviceAuthService();
541 if (ret != HC_SUCCESS) {
542 return ret;
543 }
544 do {
545 const CredManager *cm = GetCredMgrInstance();
546 char *credId = nullptr;
547 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
548 HcFree(credId);
549 char *returnData = nullptr;
550 ret = cm->exportCredential(DEFAULT_OS_ACCOUNT, nullptr, &returnData);
551 } while (0);
552 DestroyDeviceAuthService();
553 return ret;
554 }
555
IdentityServiceTestCase021(void)556 static int32_t IdentityServiceTestCase021(void)
557 {
558 DeleteDatabase();
559 int32_t ret = InitDeviceAuthService();
560 if (ret != HC_SUCCESS) {
561 return ret;
562 }
563 do {
564 const CredManager *cm = GetCredMgrInstance();
565 char *returnData = nullptr;
566 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &returnData);
567 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS14, &returnData);
568 HcFree(returnData);
569 char *credIdList = nullptr;
570 ret = cm->queryCredentialByParams(DEFAULT_OS_ACCOUNT, QUERY_PARAMS, &credIdList);
571 CJson *jsonArr = CreateJsonFromString(credIdList);
572 HcFree(credIdList);
573 FreeJson(jsonArr);
574 } while (0);
575 DestroyDeviceAuthService();
576 return ret;
577 }
578
IdentityServiceTestCase022(void)579 static int32_t IdentityServiceTestCase022(void)
580 {
581 DeleteDatabase();
582 int32_t ret = InitDeviceAuthService();
583 if (ret != HC_SUCCESS) {
584 return ret;
585 }
586 do {
587 const CredManager *cm = GetCredMgrInstance();
588 char *credIdList = nullptr;
589 ret = cm->queryCredentialByParams(DEFAULT_OS_ACCOUNT, nullptr, &credIdList);
590 } while (0);
591 DestroyDeviceAuthService();
592 return ret;
593 }
594
IdentityServiceTestCase023(void)595 static int32_t IdentityServiceTestCase023(void)
596 {
597 DeleteDatabase();
598 int32_t ret = InitDeviceAuthService();
599 if (ret != HC_SUCCESS) {
600 return ret;
601 }
602 do {
603 const CredManager *cm = GetCredMgrInstance();
604 ret = cm->queryCredentialByParams(DEFAULT_OS_ACCOUNT, QUERY_PARAMS, nullptr);
605 } while (0);
606 DestroyDeviceAuthService();
607 return ret;
608 }
609
IdentityServiceTestCase024(void)610 static int32_t IdentityServiceTestCase024(void)
611 {
612 DeleteDatabase();
613 int32_t ret = InitDeviceAuthService();
614 if (ret != HC_SUCCESS) {
615 return ret;
616 }
617 do {
618 const CredManager *cm = GetCredMgrInstance();
619 char *returnData = nullptr;
620 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &returnData);
621 HcFree(returnData);
622 char *credIdList = nullptr;
623 ret = cm->queryCredentialByParams(DEFAULT_OS_ACCOUNT, QUERY_PARAMS1, &credIdList);
624 CJson *jsonArr = CreateJsonFromString(credIdList);
625 HcFree(credIdList);
626 FreeJson(jsonArr);
627 } while (0);
628 DestroyDeviceAuthService();
629 return ret;
630 }
631
IdentityServiceTestCase025(void)632 static int32_t IdentityServiceTestCase025(void)
633 {
634 DeleteDatabase();
635 int32_t ret = InitDeviceAuthService();
636 if (ret != HC_SUCCESS) {
637 return ret;
638 }
639 do {
640 const CredManager *cm = GetCredMgrInstance();
641 char *credId = nullptr;
642 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
643 char *returnCredInfo = nullptr;
644 ret = cm->queryCredInfoByCredId(DEFAULT_OS_ACCOUNT, credId, &returnCredInfo);
645 HcFree(credId);
646 CJson *credInfoJson = CreateJsonFromString(returnCredInfo);
647 HcFree(returnCredInfo);
648 FreeJson(credInfoJson);
649 } while (0);
650 DestroyDeviceAuthService();
651 return ret;
652 }
653
IdentityServiceTestCase026(void)654 static int32_t IdentityServiceTestCase026(void)
655 {
656 DeleteDatabase();
657 int32_t ret = InitDeviceAuthService();
658 if (ret != HC_SUCCESS) {
659 return ret;
660 }
661 do {
662 const CredManager *cm = GetCredMgrInstance();
663 char *returnCredInfo = nullptr;
664 ret = cm->queryCredInfoByCredId(DEFAULT_OS_ACCOUNT, nullptr, &returnCredInfo);
665 } while (0);
666 DestroyDeviceAuthService();
667 return ret;
668 }
669
IdentityServiceTestCase027(void)670 static int32_t IdentityServiceTestCase027(void)
671 {
672 DeleteDatabase();
673 int32_t ret = InitDeviceAuthService();
674 if (ret != HC_SUCCESS) {
675 return ret;
676 }
677 do {
678 const CredManager *cm = GetCredMgrInstance();
679 char *returnCredInfo = nullptr;
680 ret = cm->queryCredInfoByCredId(DEFAULT_OS_ACCOUNT, nullptr, &returnCredInfo);
681 } while (0);
682 DestroyDeviceAuthService();
683 return ret;
684 }
685
IdentityServiceTestCase028(void)686 static int32_t IdentityServiceTestCase028(void)
687 {
688 DeleteDatabase();
689 int32_t ret = InitDeviceAuthService();
690 if (ret != HC_SUCCESS) {
691 return ret;
692 }
693 do {
694 const CredManager *cm = GetCredMgrInstance();
695 char *credId = nullptr;
696 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS14, &credId);
697 ret = cm->queryCredInfoByCredId(DEFAULT_OS_ACCOUNT, credId, nullptr);
698 HcFree(credId);
699 } while (0);
700 DestroyDeviceAuthService();
701 return ret;
702 }
703
IdentityServiceTestCase029(void)704 static int32_t IdentityServiceTestCase029(void)
705 {
706 DeleteDatabase();
707 int32_t ret = InitDeviceAuthService();
708 if (ret != HC_SUCCESS) {
709 return ret;
710 }
711 do {
712 const CredManager *cm = GetCredMgrInstance();
713 char *credId = nullptr;
714 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
715 ret = cm->deleteCredential(DEFAULT_OS_ACCOUNT, credId);
716 HcFree(credId);
717 } while (0);
718 DestroyDeviceAuthService();
719 return ret;
720 }
721
IdentityServiceTestCase031(void)722 static int32_t IdentityServiceTestCase031(void)
723 {
724 DeleteDatabase();
725 int32_t ret = InitDeviceAuthService();
726 if (ret != HC_SUCCESS) {
727 return ret;
728 }
729 do {
730 const CredManager *cm = GetCredMgrInstance();
731 ret = cm->deleteCredential(DEFAULT_OS_ACCOUNT, nullptr);
732 } while (0);
733 DestroyDeviceAuthService();
734 return ret;
735 }
736
IdentityServiceTestCase033(void)737 static int32_t IdentityServiceTestCase033(void)
738 {
739 DeleteDatabase();
740 int32_t ret = InitDeviceAuthService();
741 if (ret != HC_SUCCESS) {
742 return ret;
743 }
744 do {
745 const CredManager *cm = GetCredMgrInstance();
746 char *credId = nullptr;
747 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
748 ret = cm->updateCredInfo(DEFAULT_OS_ACCOUNT, credId, REQUEST_PARAMS);
749 HcFree(credId);
750 } while (0);
751 DestroyDeviceAuthService();
752 return ret;
753 }
754
IdentityServiceTestCase034(void)755 static int32_t IdentityServiceTestCase034(void)
756 {
757 DeleteDatabase();
758 int32_t ret = InitDeviceAuthService();
759 if (ret != HC_SUCCESS) {
760 return ret;
761 }
762 do {
763 const CredManager *cm = GetCredMgrInstance();
764 char *credId = nullptr;
765 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
766 ret = cm->updateCredInfo(DEFAULT_OS_ACCOUNT, credId, "");
767 HcFree(credId);
768 } while (0);
769 DestroyDeviceAuthService();
770 return ret;
771 }
772
IdentityServiceTestCase036(void)773 static int32_t IdentityServiceTestCase036(void)
774 {
775 DeleteDatabase();
776 int32_t ret = InitDeviceAuthService();
777 if (ret != HC_SUCCESS) {
778 return ret;
779 }
780 do {
781 const CredManager *cm = GetCredMgrInstance();
782 char *credId = nullptr;
783 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
784 ret = cm->updateCredInfo(DEFAULT_OS_ACCOUNT, nullptr, REQUEST_PARAMS);
785 HcFree(credId);
786 } while (0);
787 DestroyDeviceAuthService();
788 return ret;
789 }
790
IdentityServiceTestCase038(void)791 static int32_t IdentityServiceTestCase038(void)
792 {
793 DeleteDatabase();
794 int32_t ret = InitDeviceAuthService();
795 if (ret != HC_SUCCESS) {
796 return ret;
797 }
798 do {
799 const CredManager *cm = GetCredMgrInstance();
800 CredChangeListener listener;
801 ret = cm->registerChangeListener(TEST_APP_ID, &listener);
802 } while (0);
803 DestroyDeviceAuthService();
804 return ret;
805 }
806
IdentityServiceTestCase039(void)807 static int32_t IdentityServiceTestCase039(void)
808 {
809 DeleteDatabase();
810 int32_t ret = InitDeviceAuthService();
811 if (ret != HC_SUCCESS) {
812 return ret;
813 }
814 do {
815 const CredManager *cm = GetCredMgrInstance();
816 CredChangeListener listener;
817 ret = cm->registerChangeListener(TEST_APP_ID, &listener);
818 ret = cm->registerChangeListener(TEST_APP_ID, &listener);
819 } while (0);
820 DestroyDeviceAuthService();
821 return ret;
822 }
823
IdentityServiceTestCase040(void)824 static int32_t IdentityServiceTestCase040(void)
825 {
826 DeleteDatabase();
827 int32_t ret = InitDeviceAuthService();
828 if (ret != HC_SUCCESS) {
829 return ret;
830 }
831 do {
832 const CredManager *cm = GetCredMgrInstance();
833 CredChangeListener listener;
834 ret = cm->registerChangeListener(nullptr, &listener);
835 } while (0);
836 DestroyDeviceAuthService();
837 return ret;
838 }
839
IdentityServiceTestCase041(void)840 static int32_t IdentityServiceTestCase041(void)
841 {
842 DeleteDatabase();
843 int32_t ret = InitDeviceAuthService();
844 if (ret != HC_SUCCESS) {
845 return ret;
846 }
847 do {
848 const CredManager *cm = GetCredMgrInstance();
849 ret = cm->registerChangeListener(TEST_APP_ID, nullptr);
850 } while (0);
851 DestroyDeviceAuthService();
852 return ret;
853 }
854
IdentityServiceTestCase042(void)855 static int32_t IdentityServiceTestCase042(void)
856 {
857 DeleteDatabase();
858 int32_t ret = InitDeviceAuthService();
859 if (ret != HC_SUCCESS) {
860 return ret;
861 }
862 do {
863 g_credListenerStatus = CRED_LISTENER_INIT;
864 const CredManager *cm = GetCredMgrInstance();
865 ret = cm->registerChangeListener(TEST_APP_ID, &g_credChangeListener);
866 char *credId = nullptr;
867 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
868 HcFree(credId);
869 } while (0);
870 DestroyDeviceAuthService();
871 return ret;
872 }
873
IdentityServiceTestCase043(void)874 static int32_t IdentityServiceTestCase043(void)
875 {
876 DeleteDatabase();
877 int32_t ret = InitDeviceAuthService();
878 if (ret != HC_SUCCESS) {
879 return ret;
880 }
881 do {
882 g_credListenerStatus = CRED_LISTENER_INIT;
883 const CredManager *cm = GetCredMgrInstance();
884 ret = cm->registerChangeListener(TEST_APP_ID, &g_credChangeListener);
885 char *credId = nullptr;
886 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
887 ret = cm->updateCredInfo(DEFAULT_OS_ACCOUNT, credId, REQUEST_PARAMS);
888 HcFree(credId);
889 } while (0);
890 DestroyDeviceAuthService();
891 return ret;
892 }
893
IdentityServiceTestCase044(void)894 static int32_t IdentityServiceTestCase044(void)
895 {
896 DeleteDatabase();
897 int32_t ret = InitDeviceAuthService();
898 if (ret != HC_SUCCESS) {
899 return ret;
900 }
901 do {
902 g_credListenerStatus = CRED_LISTENER_INIT;
903 const CredManager *cm = GetCredMgrInstance();
904 ret = cm->registerChangeListener(TEST_APP_ID, &g_credChangeListener);
905 char *credId = nullptr;
906 ret = cm->addCredential(DEFAULT_OS_ACCOUNT, ADD_PARAMS, &credId);
907 ret = cm->deleteCredential(DEFAULT_OS_ACCOUNT, credId);
908 HcFree(credId);
909 } while (0);
910 DestroyDeviceAuthService();
911 return ret;
912 }
913
IdentityServiceTestCase045(void)914 static int32_t IdentityServiceTestCase045(void)
915 {
916 DeleteDatabase();
917 int32_t ret = InitDeviceAuthService();
918 if (ret != HC_SUCCESS) {
919 return ret;
920 }
921 do {
922 const CredManager *cm = GetCredMgrInstance();
923 CredChangeListener listener;
924 ret = cm->registerChangeListener(TEST_APP_ID, &listener);
925 ret = cm->unregisterChangeListener(TEST_APP_ID);
926 } while (0);
927 DestroyDeviceAuthService();
928 return ret;
929 }
930
IdentityServiceTestCase046(void)931 static int32_t IdentityServiceTestCase046(void)
932 {
933 DeleteDatabase();
934 int32_t ret = InitDeviceAuthService();
935 if (ret != HC_SUCCESS) {
936 return ret;
937 }
938 do {
939 const CredManager *cm = GetCredMgrInstance();
940 ret = cm->unregisterChangeListener(TEST_APP_ID);
941 } while (0);
942 DestroyDeviceAuthService();
943 return ret;
944 }
945
IdentityServiceTestCase047(void)946 static int32_t IdentityServiceTestCase047(void)
947 {
948 DeleteDatabase();
949 int32_t ret = InitDeviceAuthService();
950 if (ret != HC_SUCCESS) {
951 return ret;
952 }
953 do {
954 const CredManager *cm = GetCredMgrInstance();
955 ret = cm->unregisterChangeListener(nullptr);
956 } while (0);
957 DestroyDeviceAuthService();
958 return ret;
959 }
960
AddCredFuzzPart(void)961 static void AddCredFuzzPart(void)
962 {
963 (void)IdentityServiceTestCase001();
964 (void)IdentityServiceTestCase002();
965 (void)IdentityServiceTestCase003();
966 (void)IdentityServiceTestCase004();
967 (void)IdentityServiceTestCase005();
968 (void)IdentityServiceTestCase006();
969 (void)IdentityServiceTestCase007();
970 (void)IdentityServiceTestCase008();
971 (void)IdentityServiceTestCase009();
972 (void)IdentityServiceTestCase010();
973 (void)IdentityServiceTestCase011();
974 (void)IdentityServiceTestCase012();
975 (void)IdentityServiceTestCase013();
976 (void)IdentityServiceTestCase014();
977 (void)IdentityServiceTestCase015();
978 (void)IdentityServiceTestCase016();
979 (void)IdentityServiceTestCase048();
980 }
981
ExportCredFuzzPart(void)982 static void ExportCredFuzzPart(void)
983 {
984 (void)IdentityServiceTestCase017();
985 (void)IdentityServiceTestCase018();
986 (void)IdentityServiceTestCase019();
987 (void)IdentityServiceTestCase020();
988 }
989
QueryCredFuzzPart(void)990 static void QueryCredFuzzPart(void)
991 {
992 (void)IdentityServiceTestCase021();
993 (void)IdentityServiceTestCase022();
994 (void)IdentityServiceTestCase023();
995 (void)IdentityServiceTestCase024();
996 (void)IdentityServiceTestCase025();
997 (void)IdentityServiceTestCase026();
998 (void)IdentityServiceTestCase027();
999 (void)IdentityServiceTestCase028();
1000 }
1001
DelCredFuzzPart(void)1002 static void DelCredFuzzPart(void)
1003 {
1004 (void)IdentityServiceTestCase029();
1005 (void)IdentityServiceTestCase031();
1006 }
1007
UpdateCredFuzzPart(void)1008 static void UpdateCredFuzzPart(void)
1009 {
1010 (void)IdentityServiceTestCase033();
1011 (void)IdentityServiceTestCase034();
1012 (void)IdentityServiceTestCase036();
1013 }
1014
CredListenerFuzzPart(void)1015 static void CredListenerFuzzPart(void)
1016 {
1017 (void)IdentityServiceTestCase038();
1018 (void)IdentityServiceTestCase039();
1019 (void)IdentityServiceTestCase040();
1020 (void)IdentityServiceTestCase041();
1021 (void)IdentityServiceTestCase042();
1022 (void)IdentityServiceTestCase043();
1023 (void)IdentityServiceTestCase044();
1024 (void)IdentityServiceTestCase045();
1025 (void)IdentityServiceTestCase046();
1026 (void)IdentityServiceTestCase047();
1027 }
1028
1029
FuzzDoCallback(const uint8_t * data,size_t size)1030 bool FuzzDoCallback(const uint8_t* data, size_t size)
1031 {
1032 (void)data;
1033 (void)size;
1034 (void)AddCredFuzzPart();
1035 (void)ExportCredFuzzPart();
1036 (void)QueryCredFuzzPart();
1037 (void)DelCredFuzzPart();
1038 (void)UpdateCredFuzzPart();
1039 (void)CredListenerFuzzPart();
1040 return true;
1041 }
1042 }
1043 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1044 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1045 {
1046 /* Run your code on data */
1047 OHOS::FuzzDoCallback(data, size);
1048 return 0;
1049 }
1050
1051