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