1 /*
2  * Copyright (c) 2023-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 <string>
17 
18 #include "device_manager_service_listener.h"
19 #include "auth_message_processor.h"
20 #include "dm_auth_manager.h"
21 #include "dm_auth_manager_fuzzer.h"
22 #include "dm_timer.h"
23 #include "hichain_connector.h"
24 
25 namespace OHOS {
26 namespace DistributedHardware {
27 
28 std::shared_ptr<SoftbusConnector> g_softbusConnector = std::make_shared<SoftbusConnector>();
29 std::shared_ptr<IDeviceManagerServiceListener> g_listener = std::make_shared<DeviceManagerServiceListener>();
30 std::shared_ptr<HiChainConnector> g_hiChainConnector = std::make_shared<HiChainConnector>();
31 std::shared_ptr<HiChainAuthConnector> g_hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
32 std::shared_ptr<AuthRequestState> g_authRequestState = std::make_shared<AuthRequestNetworkState>();
33 std::shared_ptr<AuthResponseState> g_authResponseState = std::make_shared<AuthResponseInitState>();
34 std::shared_ptr<DmAuthManager> g_authManager =
35     std::make_shared<DmAuthManager>(g_softbusConnector, g_hiChainConnector, g_listener, g_hiChainAuthConnector);
36 
37 int32_t g_sessionId = 1;
38 int32_t g_sessionSide = 0;
39 int32_t g_result = 1;
40 int32_t g_authType = 1;
41 int32_t g_status = 1;
42 int32_t g_pinCode = 1;
43 int32_t g_action = 1;
44 int32_t g_userId = 1;
45 int32_t g_pageId = 1;
46 int32_t g_reason = 1;
47 int32_t g_state = 1;
48 int64_t g_requestId = 1;
49 
50 std::map<std::string, std::string> g_bindParam;
51 
52 PeerTargetId g_targetId = {
53     .deviceId = "deviceId",
54     .brMac = "brMac",
55     .bleMac = "bleMac",
56     .wifiIp = "wifiIp",
57 };
58 
DmAuthManagerFuzzTest(const uint8_t * data,size_t size)59 void DmAuthManagerFuzzTest(const uint8_t* data, size_t size)
60 {
61     if ((data == nullptr) || (size < sizeof(int32_t))) {
62         return;
63     }
64     std::string str(reinterpret_cast<const char*>(data), size);
65     g_authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(g_authManager);
66     g_authManager->authMessageProcessor_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
67     g_authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
68     g_authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
69     g_authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
70     g_authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
71     g_authManager->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
72     g_authManager->softbusConnector_ = std::make_shared<SoftbusConnector>();
73     g_authManager->softbusConnector_->GetSoftbusSession()->
74         RegisterSessionCallback(std::shared_ptr<ISoftbusSessionCallback>(g_authManager));
75     g_authManager->timer_ = std::make_shared<DmTimer>();
76 
77     g_authManager->InitAuthState(str, g_authType, str, str);
78     g_authManager->OnSessionOpened(g_sessionId, g_sessionSide, g_result);
79     g_authManager->AuthenticateDevice(str, g_authType, str, str);
80     g_authManager->ImportAuthCode(str, str);
81     g_authManager->BindTarget(str, g_targetId, g_bindParam);
82     g_authManager->ShowConfigDialog();
83     g_authManager->ShowAuthInfoDialog();
84     g_authManager->ShowStartAuthDialog();
85     g_authManager->OnDataReceived(g_sessionId, str);
86     g_authManager->OnGroupCreated(g_requestId, str);
87     g_authManager->OnMemberJoin(g_requestId, g_status);
88     g_authManager->StartNegotiate(g_sessionId);
89     g_authManager->RespNegotiate(g_sessionId);
90     g_authManager->SendAuthRequest(g_sessionId);
91     g_authManager->SetAuthRequestState(g_authRequestState);
92     g_authManager->SetAuthResponseState(g_authResponseState);
93     g_authManager->StartAuthProcess(g_action);
94     g_authManager->StartRespAuthProcess();
95     g_authManager->CreateGroup();
96     g_authManager->ProcessPincode(g_pinCode);
97     g_authManager->UserSwitchEventCallback(g_userId);
98     g_authManager->SetPageId(g_pageId);
99     g_authManager->SetReasonAndFinish(g_reason, g_state);
100     g_authManager->IsIdenticalAccount();
101     g_authManager->OnSessionClosed(g_sessionId);
102     g_authManager->OnUserOperation(g_action, str);
103     g_authManager->GetConnectAddr(str);
104     g_authManager->HandleAuthenticateTimeout(str);
105     g_authManager->RegisterUiStateCallback(str);
106     g_authManager->UnRegisterUiStateCallback(str);
107     g_authManager->UnAuthenticateDevice(str, str);
108     g_authManager->UnBindDevice(str, str);
109 }
110 }
111 }
112 
113 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)114 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
115 {
116     /* Run your code on data */
117     OHOS::DistributedHardware::DmAuthManagerFuzzTest(data, size);
118 
119     return 0;
120 }