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 "dlspeke_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20
21 #include "device_auth_defines.h"
22 #include "hc_types.h"
23 #include "hks_api.h"
24 #include "hks_param.h"
25 #include "hks_type.h"
26 #include "dl_speke_protocol.h"
27 #include "json_utils.h"
28 #include "uint8buff_utils.h"
29 #include "device_auth.h"
30 #include "base/security/device_auth/services/session_manager/src/session/v2/auth_sub_session/protocol_lib/dl_speke_protocol.c"
31
32
33 namespace OHOS {
34 #define PSK_SIZE 32
35 #define INVALID_CURVE_TYPE 0
36 static const uint8_t PSK_VAL[PSK_SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
37 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
38 static const char *AUTH_ID_C_VAL = "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930";
39 static const char *AUTH_ID_S_VAL = "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C";
40 static const char *MSG_C_VAL = "client send msg";
41 static const char *MSG_S_VAL = "server send msg";
42 static const int32_t ERROR_CODE = 0;
43
44 static Uint8Buff g_psk = { (uint8_t *)PSK_VAL, PSK_SIZE };
45 static Uint8Buff g_authIdC = { (uint8_t *)AUTH_ID_C_VAL, 64 };
46 static Uint8Buff g_authIdS = { (uint8_t *)AUTH_ID_S_VAL, 64 };
47 static Uint8Buff g_msgC = { (uint8_t *)MSG_C_VAL, 16 };
48 static Uint8Buff g_msgS = { (uint8_t *)MSG_S_VAL, 16 };
49 static DlSpekeInitParams g_prime384ParamsC = { DL_SPEKE_PRIME_MOD_384, g_authIdC, DEFAULT_OS_ACCOUNT };
50 static DlSpekeInitParams g_prime384ParamsS = { DL_SPEKE_PRIME_MOD_384, g_authIdS, DEFAULT_OS_ACCOUNT };
51 static DlSpekeInitParams g_prime256ParamsC = { DL_SPEKE_PRIME_MOD_256, g_authIdC, DEFAULT_OS_ACCOUNT };
52 static DlSpekeInitParams g_prime256ParamsS = { DL_SPEKE_PRIME_MOD_256, g_authIdS, DEFAULT_OS_ACCOUNT };
53
DlSpekeTest01(void)54 static void DlSpekeTest01(void)
55 {
56 HksInitialize();
57 BaseProtocol *self;
58 CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
59 self->destroy(self);
60 }
61
DlSpekeTest02(void)62 static void DlSpekeTest02(void)
63 {
64 HksInitialize();
65 BaseProtocol *client;
66 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &client);
67
68 BaseProtocol *server;
69 res = CreateDlSpekeProtocol(&g_prime384ParamsS, false, &server);
70
71 res = client->setPsk(client, &g_psk);
72 res = server->setPsk(server, &g_psk);
73
74 CJson *clientOut = nullptr;
75 CJson *serverOut = nullptr;
76
77 res = client->setSelfProtectedMsg(client, &g_msgC);
78 res = client->setPeerProtectedMsg(client, &g_msgS);
79 res = server->setSelfProtectedMsg(server, &g_msgS);
80 res = server->setPeerProtectedMsg(server, &g_msgC);
81
82 res = client->start(client, &clientOut);
83
84 while (clientOut != nullptr || serverOut != nullptr) {
85 if (clientOut != nullptr) {
86 res = server->process(server, clientOut, &serverOut);
87 FreeJson(clientOut);
88 clientOut = nullptr;
89 } else {
90 res = client->process(client, serverOut, &clientOut);
91 FreeJson(serverOut);
92 serverOut = nullptr;
93 }
94 }
95 Uint8Buff clientKey = { nullptr, 0 };
96 res = client->getSessionKey(client, &clientKey);
97 FreeUint8Buff(&clientKey);
98 Uint8Buff serverKey = { nullptr, 0 };
99 res = server->getSessionKey(server, &serverKey);
100 FreeUint8Buff(&serverKey);
101
102 client->destroy(client);
103 server->destroy(server);
104 }
105
DlSpekeTest03(void)106 static void DlSpekeTest03(void)
107 {
108 HksInitialize();
109 BaseProtocol *client;
110 int32_t res = CreateDlSpekeProtocol(&g_prime256ParamsC, true, &client);
111
112 BaseProtocol *server;
113 res = CreateDlSpekeProtocol(&g_prime256ParamsS, false, &server);
114
115 res = client->setPsk(client, &g_psk);
116 res = server->setPsk(server, &g_psk);
117
118 CJson *clientOut = nullptr;
119 CJson *serverOut = nullptr;
120
121 res = client->setSelfProtectedMsg(client, &g_msgC);
122 res = client->setPeerProtectedMsg(client, &g_msgS);
123 res = server->setSelfProtectedMsg(server, &g_msgS);
124 res = server->setPeerProtectedMsg(server, &g_msgC);
125
126 res = client->start(client, &clientOut);
127
128 while (clientOut != nullptr || serverOut != nullptr) {
129 if (clientOut != nullptr) {
130 res = server->process(server, clientOut, &serverOut);
131 FreeJson(clientOut);
132 clientOut = nullptr;
133 } else {
134 res = client->process(client, serverOut, &clientOut);
135 FreeJson(serverOut);
136 serverOut = nullptr;
137 }
138 }
139 Uint8Buff clientKey = { nullptr, 0 };
140 res = client->getSessionKey(client, &clientKey);
141 FreeUint8Buff(&clientKey);
142 Uint8Buff serverKey = { nullptr, 0 };
143 res = server->getSessionKey(server, &serverKey);
144 FreeUint8Buff(&serverKey);
145
146 client->destroy(client);
147 server->destroy(server);
148 }
149
DlSpekeTest04(void)150 static void DlSpekeTest04(void)
151 {
152 HksInitialize();
153 BaseProtocol *client;
154 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &client);
155
156 BaseProtocol *server;
157 res = CreateDlSpekeProtocol(&g_prime384ParamsS, false, &server);
158
159 res = client->setPsk(client, &g_psk);
160 res = server->setPsk(server, &g_psk);
161
162 CJson *clientOut = nullptr;
163 CJson *serverOut = nullptr;
164
165 res = client->start(client, &clientOut);
166
167 while (clientOut != nullptr || serverOut != nullptr) {
168 if (clientOut != nullptr) {
169 res = server->process(server, clientOut, &serverOut);
170 FreeJson(clientOut);
171 clientOut = nullptr;
172 } else {
173 res = client->process(client, serverOut, &clientOut);
174 FreeJson(serverOut);
175 serverOut = nullptr;
176 }
177 }
178 Uint8Buff clientKey;
179 res = client->getSessionKey(client, &clientKey);
180 FreeUint8Buff(&clientKey);
181 Uint8Buff serverKey;
182 res = server->getSessionKey(server, &serverKey);
183 FreeUint8Buff(&serverKey);
184
185 client->destroy(client);
186 server->destroy(server);
187 }
188
DlSpekeTest05(void)189 static void DlSpekeTest05(void)
190 {
191 HksInitialize();
192 BaseProtocol *self;
193 CreateDlSpekeProtocol(nullptr, true, &self);
194 }
195
DlSpekeTest06(void)196 static void DlSpekeTest06(void)
197 {
198 HksInitialize();
199 CreateDlSpekeProtocol(&g_prime384ParamsC, true, nullptr);
200 }
201
DlSpekeTest07(void)202 static void DlSpekeTest07(void)
203 {
204 HksInitialize();
205 DlSpekeInitParams errParams = { DL_SPEKE_PRIME_MOD_384, { nullptr, 0 }, DEFAULT_OS_ACCOUNT };
206 BaseProtocol *self;
207 CreateDlSpekeProtocol(&errParams, true, &self);
208 }
209
DlSpekeTest08(void)210 static void DlSpekeTest08(void)
211 {
212 HksInitialize();
213 BaseProtocol *self;
214 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
215
216 res = self->setPsk(nullptr, &g_psk);
217
218 self->destroy(self);
219 }
220
DlSpekeTest09(void)221 static void DlSpekeTest09(void)
222 {
223 HksInitialize();
224 BaseProtocol *self;
225 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
226
227 res = self->setPsk(self, nullptr);
228
229 self->destroy(self);
230 }
231
DlSpekeTest10(void)232 static void DlSpekeTest10(void)
233 {
234 HksInitialize();
235 BaseProtocol *self;
236 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
237
238 Uint8Buff errParams = { nullptr, PSK_SIZE };
239 res = self->setPsk(self, &errParams);
240
241 self->destroy(self);
242 }
243
DlSpekeTest11(void)244 static void DlSpekeTest11(void)
245 {
246 HksInitialize();
247 BaseProtocol *self;
248 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
249
250 Uint8Buff errParams = { (uint8_t *)PSK_VAL, 0 };
251 res = self->setPsk(self, &errParams);
252
253 self->destroy(self);
254 }
255
DlSpekeTest12(void)256 static void DlSpekeTest12(void)
257 {
258 HksInitialize();
259 BaseProtocol *self;
260 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
261
262 CJson *out = nullptr;
263 res = self->start(nullptr, &out);
264
265 self->destroy(self);
266 }
267
DlSpekeTest13(void)268 static void DlSpekeTest13(void)
269 {
270 HksInitialize();
271 BaseProtocol *self;
272 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
273
274 res = self->start(self, nullptr);
275
276 self->destroy(self);
277 }
278
DlSpekeTest14(void)279 static void DlSpekeTest14(void)
280 {
281 HksInitialize();
282 BaseProtocol *self;
283 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
284
285 self->curState = self->finishState;
286
287 CJson *out = nullptr;
288 res = self->start(self, &out);
289
290 self->destroy(self);
291 }
292
DlSpekeTest15(void)293 static void DlSpekeTest15(void)
294 {
295 HksInitialize();
296 BaseProtocol *self;
297 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
298
299 self->curState = self->failState;
300
301 CJson *out = nullptr;
302 res = self->start(self, &out);
303
304 self->destroy(self);
305 }
306
DlSpekeTest16(void)307 static void DlSpekeTest16(void)
308 {
309 HksInitialize();
310 BaseProtocol *self;
311 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
312
313 CJson recvMsg;
314 CJson *sendMsg = nullptr;
315 res = self->process(nullptr, &recvMsg, &sendMsg);
316
317 self->destroy(self);
318 }
319
DlSpekeTest17(void)320 static void DlSpekeTest17(void)
321 {
322 HksInitialize();
323 BaseProtocol *self;
324 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
325
326 CJson *sendMsg = nullptr;
327 res = self->process(self, nullptr, &sendMsg);
328
329 self->destroy(self);
330 }
331
DlSpekeTest18(void)332 static void DlSpekeTest18(void)
333 {
334 HksInitialize();
335 BaseProtocol *self;
336 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
337
338 CJson recvMsg;
339 res = self->process(self, &recvMsg, nullptr);
340
341 self->destroy(self);
342 }
343
DlSpekeTest19(void)344 static void DlSpekeTest19(void)
345 {
346 HksInitialize();
347 BaseProtocol *self;
348 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
349
350 self->curState = self->finishState;
351
352 CJson recvMsg;
353 CJson *sendMsg = nullptr;
354 res = self->process(self, &recvMsg, &sendMsg);
355
356 self->destroy(self);
357 }
358
DlSpekeTest20(void)359 static void DlSpekeTest20(void)
360 {
361 HksInitialize();
362 BaseProtocol *self;
363 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
364
365 self->curState = self->failState;
366
367 CJson recvMsg;
368 CJson *sendMsg = nullptr;
369 res = self->process(self, &recvMsg, &sendMsg);
370
371 self->destroy(self);
372 }
373
DlSpekeTest21(void)374 static void DlSpekeTest21(void)
375 {
376 HksInitialize();
377 BaseProtocol *self;
378 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
379
380 res = self->setSelfProtectedMsg(nullptr, &g_msgC);
381
382 self->destroy(self);
383 }
384
DlSpekeTest22(void)385 static void DlSpekeTest22(void)
386 {
387 HksInitialize();
388 BaseProtocol *self;
389 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
390
391 res = self->setSelfProtectedMsg(self, nullptr);
392
393 self->destroy(self);
394 }
395
DlSpekeTest23(void)396 static void DlSpekeTest23(void)
397 {
398 HksInitialize();
399 BaseProtocol *self;
400 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
401
402 res = self->setPeerProtectedMsg(nullptr, &g_msgS);
403
404 self->destroy(self);
405 }
406
DlSpekeTest24(void)407 static void DlSpekeTest24(void)
408 {
409 HksInitialize();
410 BaseProtocol *self;
411 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
412
413 res = self->setPeerProtectedMsg(self, nullptr);
414
415 self->destroy(self);
416 }
417
DlSpekeTest25(void)418 static void DlSpekeTest25(void)
419 {
420 HksInitialize();
421 BaseProtocol *self;
422 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
423
424 Uint8Buff key = { nullptr, 0 };
425 res = self->getSessionKey(nullptr, &key);
426
427 self->destroy(self);
428 }
429
DlSpekeTest26(void)430 static void DlSpekeTest26(void)
431 {
432 HksInitialize();
433 BaseProtocol *self;
434 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
435
436 res = self->getSessionKey(self, nullptr);
437
438 self->destroy(self);
439 }
440
DlSpekeTest27(void)441 static void DlSpekeTest27(void)
442 {
443 HksInitialize();
444 BaseProtocol *self;
445 int32_t res = CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
446
447 Uint8Buff key = { nullptr, 0 };
448 res = self->getSessionKey(self, &key);
449
450 self->destroy(self);
451 }
452
DlSpekeTest28(void)453 static void DlSpekeTest28(void)
454 {
455 HksInitialize();
456 BaseProtocol *self;
457 CreateDlSpekeProtocol(&g_prime384ParamsC, true, &self);
458
459 self->destroy(nullptr);
460 self->destroy(self);
461 }
462
DlSpekeTest29(void)463 static void DlSpekeTest29(void)
464 {
465 CJson *json = CreateJson();
466 ReturnError(ERROR_CODE, nullptr);
467 NotifyPeerError(ERROR_CODE, &json);
468 ThrowException(nullptr, nullptr, nullptr);
469 FreeJson(json);
470 }
471
FuzzDoCallback(const uint8_t * data,size_t size)472 bool FuzzDoCallback(const uint8_t* data, size_t size)
473 {
474 (void)data;
475 (void)size;
476 (void)DlSpekeTest01();
477 (void)DlSpekeTest02();
478 (void)DlSpekeTest03();
479 (void)DlSpekeTest04();
480 (void)DlSpekeTest05();
481 (void)DlSpekeTest06();
482 (void)DlSpekeTest07();
483 (void)DlSpekeTest08();
484 (void)DlSpekeTest09();
485 (void)DlSpekeTest10();
486 (void)DlSpekeTest11();
487 (void)DlSpekeTest12();
488 (void)DlSpekeTest13();
489 (void)DlSpekeTest14();
490 (void)DlSpekeTest15();
491 (void)DlSpekeTest16();
492 (void)DlSpekeTest17();
493 (void)DlSpekeTest18();
494 (void)DlSpekeTest19();
495 (void)DlSpekeTest20();
496 (void)DlSpekeTest21();
497 (void)DlSpekeTest22();
498 (void)DlSpekeTest23();
499 (void)DlSpekeTest24();
500 (void)DlSpekeTest25();
501 (void)DlSpekeTest26();
502 (void)DlSpekeTest27();
503 (void)DlSpekeTest28();
504 (void)DlSpekeTest29();
505 return true;
506 }
507 }
508
509 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)510 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
511 {
512 /* Run your code on data */
513 OHOS::FuzzDoCallback(data, size);
514 return 0;
515 }
516
517