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 "getcredentialinfo_fuzzer.h"
17
18 #include <string>
19 #include <vector>
20 #define private public
21 #include "account_iam_client.h"
22 #include "account_i_a_m_proxy.h"
23 #undef private
24 #include "fuzz_data.h"
25
26
27 using namespace std;
28 using namespace OHOS::AccountSA;
29
30 class MockIDMCallback : public OHOS::AccountSA::GetCredInfoCallback {
31 public:
~MockIDMCallback()32 virtual ~MockIDMCallback() {}
OnCredentialInfo(int32_t result,const std::vector<CredentialInfo> & infoList)33 void OnCredentialInfo(int32_t result, const std::vector<CredentialInfo> &infoList) override
34 {
35 return;
36 }
37 };
38
39 class MockPreRemoteAuthCallback : public OHOS::AccountSA::PreRemoteAuthCallback {
40 public:
OnResult(int32_t result)41 void OnResult(int32_t result)
42 {
43 return;
44 }
~MockPreRemoteAuthCallback()45 virtual ~MockPreRemoteAuthCallback() {}
46 };
47 class PreRemoteAuthCallbackMockTest final : public OHOS::AccountSA::PreRemoteAuthCallback {
48 public:
OnResult(int32_t result)49 void OnResult(int32_t result) override
50 {
51 result_ = result;
52 }
53 int32_t result_;
54 };
55
56 class MockIDMCallback1 : public OHOS::AccountSA::IDMCallback {
57 public:
~MockIDMCallback1()58 virtual ~MockIDMCallback1() {}
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)59 void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override
60 {
61 return;
62 }
OnResult(int32_t result,const Attributes & extraInfo)63 void OnResult(int32_t result, const Attributes &extraInfo) override
64 {
65 return;
66 }
67 };
68
69 class MockGetEnrolledIdCallback final : public GetEnrolledIdCallback {
70 public:
OnEnrolledId(int32_t result,uint64_t enrolledId)71 void OnEnrolledId(int32_t result, uint64_t enrolledId) override
72 {
73 result_ = result;
74 return;
75 }
76
77 public:
78 int32_t result_ = -1;
79 };
80
81 class MockIInputer : public OHOS::AccountSA::IInputer {
82 public:
~MockIInputer()83 virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)84 void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
85 std::shared_ptr<IInputerData> inputerData) override
86 {
87 return;
88 }
89 };
90
91 namespace OHOS {
GetCredentialInfoFuzzTest(const uint8_t * data,size_t size)92 bool GetCredentialInfoFuzzTest(const uint8_t* data, size_t size)
93 {
94 if ((data == nullptr) || (size == 0)) {
95 return false;
96 }
97 FuzzData fuzzData(data, size);
98 int32_t userId = fuzzData.GetData<int32_t>();
99 AuthType authType = fuzzData.GenerateEnmu(UserIam::UserAuth::RECOVERY_KEY);
100 std::shared_ptr<GetCredInfoCallback> callback = nullptr;
101 bool isInitCallback = fuzzData.GetData<bool>();
102 if (isInitCallback) {
103 callback = make_shared<MockIDMCallback>();
104 }
105 int32_t result = AccountIAMClient::GetInstance().GetCredentialInfo(userId, authType, callback);
106 return result == ERR_OK;
107 }
108
StartDomainAuthFuzzTest(const uint8_t * data,size_t size)109 bool StartDomainAuthFuzzTest(const uint8_t* data, size_t size)
110 {
111 if ((data == nullptr) || (size == 0)) {
112 return false;
113 }
114 FuzzData fuzzData(data, size);
115 int32_t userId = fuzzData.GetData<int32_t>();
116 std::shared_ptr<IDMCallback> callback = make_shared<MockIDMCallback1>();
117 int32_t result = AccountIAMClient::GetInstance().StartDomainAuth(userId, callback);
118 return result == ERR_OK;
119 }
120
PrepareRemoteAuthFuzzTest(const uint8_t * data,size_t size)121 bool PrepareRemoteAuthFuzzTest(const uint8_t* data, size_t size)
122 {
123 if ((data == nullptr) || (size == 0)) {
124 return false;
125 }
126 FuzzData fuzzData(data, size);
127 std::string remoteNetworkId(fuzzData.GenerateString());
128 std::shared_ptr<PreRemoteAuthCallback> callback = nullptr;
129 bool isInitCallback = fuzzData.GetData<bool>();
130 if (isInitCallback) {
131 callback = make_shared<MockPreRemoteAuthCallback>();
132 }
133 int32_t result = AccountIAMClient::GetInstance().PrepareRemoteAuth(remoteNetworkId, callback);
134 return result == ERR_OK;
135 }
136
GetEnrolledIdFuzzTest(const uint8_t * data,size_t size)137 bool GetEnrolledIdFuzzTest(const uint8_t* data, size_t size)
138 {
139 if ((data == nullptr) || (size == 0)) {
140 return false;
141 }
142 FuzzData fuzzData(data, size);
143 int32_t userId = fuzzData.GetData<int32_t>();
144 AuthType authType = static_cast<AuthType>(fuzzData.GenerateEnmu(IAMAuthType::TYPE_END));
145 auto callback = std::make_shared<MockGetEnrolledIdCallback>();
146 bool isNullCallback = fuzzData.GetData<bool>();
147 if (isNullCallback) {
148 callback = nullptr;
149 }
150 AccountIAMClient::GetInstance().GetEnrolledId(userId, authType, callback);
151 return false;
152 }
153
OpenSessionFuzzTest(const uint8_t * data,size_t size)154 bool OpenSessionFuzzTest(const uint8_t* data, size_t size)
155 {
156 if ((data == nullptr) || (size == 0)) {
157 return false;
158 }
159 FuzzData fuzzData(data, size);
160 int32_t userId = fuzzData.GetData<int32_t>();
161 std::shared_ptr<AccountIAMProxy> accountIAMMgrProxy = std::make_shared<AccountIAMProxy>(nullptr);
162 std::vector<uint8_t> challenge;
163 int32_t result = accountIAMMgrProxy->OpenSession(userId, challenge);
164 return result == ERR_OK;
165 }
166
CloseSessionFuzzTest(const uint8_t * data,size_t size)167 bool CloseSessionFuzzTest(const uint8_t* data, size_t size)
168 {
169 if ((data == nullptr) || (size == 0)) {
170 return false;
171 }
172 FuzzData fuzzData(data, size);
173 int32_t userId = fuzzData.GetData<int32_t>();
174 std::shared_ptr<AccountIAMProxy> accountIAMMgrProxy = std::make_shared<AccountIAMProxy>(nullptr);
175 int32_t result = accountIAMMgrProxy->CloseSession(userId);
176 return result == ERR_OK;
177 }
178
CancelFuzzTest(const uint8_t * data,size_t size)179 bool CancelFuzzTest(const uint8_t* data, size_t size)
180 {
181 if ((data == nullptr) || (size == 0)) {
182 return false;
183 }
184 FuzzData fuzzData(data, size);
185 int32_t userId = fuzzData.GetData<int32_t>();
186 std::shared_ptr<AccountIAMProxy> accountIAMMgrProxy = std::make_shared<AccountIAMProxy>(nullptr);
187 int32_t result = accountIAMMgrProxy->Cancel(userId);
188 return result == ERR_OK;
189 }
190 }
191
192 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)193 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
194 {
195 /* Run your code on data */
196 OHOS::GetCredentialInfoFuzzTest(data, size);
197 OHOS::StartDomainAuthFuzzTest(data, size);
198 OHOS::PrepareRemoteAuthFuzzTest(data, size);
199 OHOS::GetEnrolledIdFuzzTest(data, size);
200 OHOS::OpenSessionFuzzTest(data, size);
201 OHOS::CloseSessionFuzzTest(data, size);
202 OHOS::CancelFuzzTest(data, size);
203 return 0;
204 }
205