1 /*
2 * Copyright (c) 2022-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 "accessmanager_fuzzer.h"
17
18 #include <algorithm>
19 #include <chrono>
20 #include <cstddef>
21 #include <cstdint>
22 #include <securec.h>
23 #include <string>
24 #include <unistd.h>
25
26 #include "device_manager.h"
27
28 #include "access_manager.h"
29 #include "distributed_hardware_errno.h"
30 #include "distributed_hardware_manager_factory.h"
31
32 namespace OHOS {
33 namespace DistributedHardware {
34 namespace {
35 constexpr uint32_t SLEEP_TIME_US = 10 * 1000;
36 }
37
OnDeviceReadyFuzzTest(const uint8_t * data,size_t size)38 void OnDeviceReadyFuzzTest(const uint8_t* data, size_t size)
39 {
40 if ((data == nullptr) || (size > DM_MAX_DEVICE_ID_LEN)) {
41 return;
42 }
43
44 AccessManager::GetInstance()->Init();
45 DmDeviceInfo deviceInfo;
46 int32_t ret = memcpy_s(deviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, (reinterpret_cast<const char *>(data)), size);
47 if (ret != EOK) {
48 return;
49 }
50 AccessManager::GetInstance()->OnDeviceReady(deviceInfo);
51
52 usleep(SLEEP_TIME_US);
53 }
54
OnDeviceOfflineFuzzTest(const uint8_t * data,size_t size)55 void OnDeviceOfflineFuzzTest(const uint8_t* data, size_t size)
56 {
57 if ((data == nullptr) || (size > DM_MAX_DEVICE_ID_LEN)) {
58 return;
59 }
60
61 AccessManager::GetInstance()->Init();
62 DmDeviceInfo deviceInfo;
63 int32_t ret = memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_ID_LEN, (reinterpret_cast<const char *>(data)), size);
64 if (ret != EOK) {
65 return;
66 }
67 AccessManager::GetInstance()->OnDeviceOffline(deviceInfo);
68 usleep(SLEEP_TIME_US);
69 }
70
OnDeviceChangedFuzzTest(const uint8_t * data,size_t size)71 void OnDeviceChangedFuzzTest(const uint8_t* data, size_t size)
72 {
73 if ((data == nullptr) || (size > DM_MAX_DEVICE_ID_LEN)) {
74 return;
75 }
76
77 AccessManager::GetInstance()->Init();
78 DmDeviceInfo deviceInfo;
79 int32_t ret = memcpy_s(deviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, (reinterpret_cast<const char *>(data)), size);
80 if (ret != EOK) {
81 return;
82 }
83 AccessManager::GetInstance()->OnDeviceChanged(deviceInfo);
84 usleep(SLEEP_TIME_US);
85 }
86
UnInitFuzzTest(const uint8_t * data,size_t size)87 void UnInitFuzzTest(const uint8_t* data, size_t size)
88 {
89 (void)data;
90 (void)size;
91 AccessManager::GetInstance()->UnInit();
92 usleep(SLEEP_TIME_US);
93 }
94
UnInitDeviceManagerFuzzTest(const uint8_t * data,size_t size)95 void UnInitDeviceManagerFuzzTest(const uint8_t* data, size_t size)
96 {
97 (void)data;
98 (void)size;
99 AccessManager::GetInstance()->UnInitDeviceManager();
100 usleep(SLEEP_TIME_US);
101 }
102
UnRegisterDevStateCallbackFuzzTest(const uint8_t * data,size_t size)103 void UnRegisterDevStateCallbackFuzzTest(const uint8_t* data, size_t size)
104 {
105 (void)data;
106 (void)size;
107 AccessManager::GetInstance()->UnRegisterDevStateCallback();
108 usleep(SLEEP_TIME_US);
109 }
110
OnRemoteDiedFuzzTest(const uint8_t * data,size_t size)111 void OnRemoteDiedFuzzTest(const uint8_t* data, size_t size)
112 {
113 (void)data;
114 (void)size;
115 AccessManager::GetInstance()->OnRemoteDied();
116 usleep(SLEEP_TIME_US);
117 }
118
CheckTrustedDeviceOnlineFuzzTest(const uint8_t * data,size_t size)119 void CheckTrustedDeviceOnlineFuzzTest(const uint8_t* data, size_t size)
120 {
121 (void)data;
122 (void)size;
123 AccessManager::GetInstance()->CheckTrustedDeviceOnline();
124 usleep(SLEEP_TIME_US);
125 }
126
OnDeviceOnlineFuzzTest(const uint8_t * data,size_t size)127 void OnDeviceOnlineFuzzTest(const uint8_t* data, size_t size)
128 {
129 if ((data == nullptr) || (size > DM_MAX_DEVICE_ID_LEN)) {
130 return;
131 }
132
133 AccessManager::GetInstance()->Init();
134 DmDeviceInfo deviceInfo;
135 int32_t ret = memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_ID_LEN, (reinterpret_cast<const char *>(data)), size);
136 if (ret != EOK) {
137 return;
138 }
139 AccessManager::GetInstance()->OnDeviceOnline(deviceInfo);
140 usleep(SLEEP_TIME_US);
141 }
142 }
143 }
144
145 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)146 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
147 {
148 /* Run your code on data */
149 OHOS::DistributedHardware::OnDeviceReadyFuzzTest(data, size);
150 OHOS::DistributedHardware::OnDeviceOnlineFuzzTest(data, size);
151 OHOS::DistributedHardware::OnDeviceChangedFuzzTest(data, size);
152 OHOS::DistributedHardware::UnInitFuzzTest(data, size);
153 OHOS::DistributedHardware::UnInitDeviceManagerFuzzTest(data, size);
154 OHOS::DistributedHardware::UnRegisterDevStateCallbackFuzzTest(data, size);
155 OHOS::DistributedHardware::OnRemoteDiedFuzzTest(data, size);
156 OHOS::DistributedHardware::CheckTrustedDeviceOnlineFuzzTest(data, size);
157 OHOS::DistributedHardware::OnDeviceOfflineFuzzTest(data, size);
158 return 0;
159 }
160
161