1 /*
2 * Copyright (c) 2022 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_iam_mgr_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 = make_shared<MockIDMCallback>();
101 int32_t result = AccountIAMClient::GetInstance().GetCredentialInfo(userId, authType, callback);
102 return result == ERR_OK;
103 }
104
StartDomainAuthFuzzTest(const uint8_t * data,size_t size)105 bool StartDomainAuthFuzzTest(const uint8_t* data, size_t size)
106 {
107 if ((data == nullptr) || (size == 0)) {
108 return false;
109 }
110 FuzzData fuzzData(data, size);
111 int32_t userId = fuzzData.GetData<int32_t>();
112 std::shared_ptr<IDMCallback> callback = make_shared<MockIDMCallback1>();
113 int32_t result = AccountIAMClient::GetInstance().StartDomainAuth(userId, callback);
114 return result == ERR_OK;
115 }
116
PrepareRemoteAuthFuzzTest(const uint8_t * data,size_t size)117 bool PrepareRemoteAuthFuzzTest(const uint8_t* data, size_t size)
118 {
119 if ((data == nullptr) || (size == 0)) {
120 return false;
121 }
122 FuzzData fuzzData(data, size);
123 std::string remoteNetworkId(fuzzData.GenerateString());
124 std::shared_ptr<PreRemoteAuthCallback> callback = make_shared<MockPreRemoteAuthCallback>();
125 int32_t result = AccountIAMClient::GetInstance().PrepareRemoteAuth(remoteNetworkId, callback);
126 return result == ERR_OK;
127 }
128
GetEnrolledIdFuzzTest(const uint8_t * data,size_t size)129 bool GetEnrolledIdFuzzTest(const uint8_t* data, size_t size)
130 {
131 if ((data == nullptr) || (size == 0)) {
132 return false;
133 }
134 FuzzData fuzzData(data, size);
135 int32_t userId = fuzzData.GetData<int32_t>();
136 AuthType authType = static_cast<AuthType>(fuzzData.GenerateEnmu(IAMAuthType::TYPE_END));
137 auto callback = std::make_shared<MockGetEnrolledIdCallback>();
138 AccountIAMClient::GetInstance().GetEnrolledId(userId, authType, callback);
139 return callback->result_ == ERR_OK;
140 }
141
OpenSessionFuzzTest(const uint8_t * data,size_t size)142 bool OpenSessionFuzzTest(const uint8_t* data, size_t size)
143 {
144 if ((data == nullptr) || (size == 0)) {
145 return false;
146 }
147 FuzzData fuzzData(data, size);
148 int32_t userId = fuzzData.GetData<int32_t>();
149 std::shared_ptr<AccountIAMMgrProxy> accountIAMMgrProxy = std::make_shared<AccountIAMMgrProxy>(nullptr);
150 std::vector<uint8_t> challenge;
151 int32_t result = accountIAMMgrProxy->OpenSession(userId, challenge);
152 return result == ERR_OK;
153 }
154
CloseSessionFuzzTest(const uint8_t * data,size_t size)155 bool CloseSessionFuzzTest(const uint8_t* data, size_t size)
156 {
157 if ((data == nullptr) || (size == 0)) {
158 return false;
159 }
160 FuzzData fuzzData(data, size);
161 int32_t userId = fuzzData.GetData<int32_t>();
162 std::shared_ptr<AccountIAMMgrProxy> accountIAMMgrProxy = std::make_shared<AccountIAMMgrProxy>(nullptr);
163 int32_t result = accountIAMMgrProxy->CloseSession(userId);
164 return result == ERR_OK;
165 }
166
CancelFuzzTest(const uint8_t * data,size_t size)167 bool CancelFuzzTest(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<AccountIAMMgrProxy> accountIAMMgrProxy = std::make_shared<AccountIAMMgrProxy>(nullptr);
175 int32_t result = accountIAMMgrProxy->Cancel(userId);
176 return result == ERR_OK;
177 }
178 }
179
180 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)181 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
182 {
183 /* Run your code on data */
184 OHOS::GetCredentialInfoFuzzTest(data, size);
185 OHOS::StartDomainAuthFuzzTest(data, size);
186 OHOS::PrepareRemoteAuthFuzzTest(data, size);
187 OHOS::GetEnrolledIdFuzzTest(data, size);
188 OHOS::OpenSessionFuzzTest(data, size);
189 OHOS::CloseSessionFuzzTest(data, size);
190 OHOS::CancelFuzzTest(data, size);
191 return 0;
192 }
193