1 /*
2 * Copyright (c) 2024-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 "procaddserverconfigstub_fuzzer.h"
17
18 #include <string>
19 #include <vector>
20
21 #include "domain_account_callback.h"
22 #include "domain_account_callback_service.h"
23 #include "domain_account_manager_service.h"
24 #include "fuzz_data.h"
25 #include "idomain_account.h"
26
27 using namespace std;
28 using namespace OHOS::AccountSA;
29
30 namespace OHOS {
31 namespace {
32 const int ENUM_MAX = 4;
33 const uint32_t TOKEN_LEN = 10;
34 const uint32_t TEST_VECTOR_MAX_SIZE = 102402;
35
36 class TestGetDomainAccountInfoCallback : public DomainAccountCallbackStub {
37 public:
TestGetDomainAccountInfoCallback()38 TestGetDomainAccountInfoCallback(){};
39 virtual ~TestGetDomainAccountInfoCallback();
40 ErrCode OnResult(int32_t errCode, const DomainAccountParcel &parcel) override;
41 };
42
~TestGetDomainAccountInfoCallback()43 TestGetDomainAccountInfoCallback::~TestGetDomainAccountInfoCallback() {}
44
OnResult(int32_t errCode,const DomainAccountParcel & parcel)45 ErrCode TestGetDomainAccountInfoCallback::OnResult(int32_t errCode, const DomainAccountParcel &parcel)
46 {
47 return ERR_OK;
48 }
49 }
50
ProcAddServerConfigStubFuzzTest(const uint8_t * data,size_t size)51 bool ProcAddServerConfigStubFuzzTest(const uint8_t* data, size_t size)
52 {
53 if ((data == nullptr) || (size == 0)) {
54 return false;
55 }
56 FuzzData fuzzData(data, size);
57 MessageParcel dataTemp;
58 if (!dataTemp.WriteInterfaceToken(DomainAccountStub::GetDescriptor())) {
59 return false;
60 }
61 if (!dataTemp.WriteString16(Str8ToStr16(fuzzData.GenerateString()))) {
62 return false;
63 }
64 MessageParcel reply;
65 MessageOption option;
66 uint32_t code = static_cast<uint32_t>(IDomainAccountIpcCode::COMMAND_ADD_SERVER_CONFIG);
67 auto domainAccountService = std::make_shared<DomainAccountManagerService>();
68 domainAccountService->OnRemoteRequest(code, dataTemp, reply, option);
69
70 return true;
71 }
72
ProcGetAccountStatusStubFuzzTest(const uint8_t * data,size_t size)73 bool ProcGetAccountStatusStubFuzzTest(const uint8_t *data, size_t size)
74 {
75 if ((data == nullptr) || (size == 0)) {
76 return false;
77 }
78
79 MessageParcel dataTemp;
80 FuzzData fuzzData(data, size);
81 if (fuzzData.GetData<bool>()) {
82 if (!dataTemp.WriteInterfaceToken(DomainAccountStub::GetDescriptor())) {
83 return false;
84 }
85 }
86 DomainAccountInfo info;
87 info.domain_ = fuzzData.GenerateString();
88 info.accountName_ = fuzzData.GenerateString();
89 info.accountId_ = fuzzData.GenerateString();
90 info.isAuthenticated = fuzzData.GenerateBool();
91 info.serverConfigId_ = fuzzData.GenerateString();
92 int typeNumber = fuzzData.GetData<int>() % ENUM_MAX;
93 info.status_ = static_cast<DomainAccountStatus>(typeNumber);
94 if (fuzzData.GetData<bool>()) {
95 if (!dataTemp.WriteParcelable(&info)) {
96 return false;
97 }
98 }
99
100 MessageParcel reply;
101 MessageOption option;
102 uint32_t code = static_cast<uint32_t>(IDomainAccountIpcCode::COMMAND_GET_ACCOUNT_STATUS);
103 auto domainAccountService = std::make_shared<DomainAccountManagerService>();
104 domainAccountService->OnRemoteRequest(code, dataTemp, reply, option);
105
106 return true;
107 }
108
ProcGetDomainAccessTokenStubFuzzTest(const uint8_t * data,size_t size)109 bool ProcGetDomainAccessTokenStubFuzzTest(const uint8_t *data, size_t size)
110 {
111 if ((data == nullptr) || (size == 0)) {
112 return false;
113 }
114
115 MessageParcel dataTemp;
116 if (!dataTemp.WriteInterfaceToken(DomainAccountStub::GetDescriptor())) {
117 return false;
118 }
119
120 DomainAccountInfo info;
121 FuzzData fuzzData(data, size);
122 info.domain_ = fuzzData.GenerateString();
123 info.accountName_ = fuzzData.GenerateString();
124 info.accountId_ = fuzzData.GenerateString();
125 info.isAuthenticated = fuzzData.GenerateBool();
126 info.serverConfigId_ = fuzzData.GenerateString();
127 int typeNumber = fuzzData.GetData<int>() % ENUM_MAX;
128 info.status_ = static_cast<DomainAccountStatus>(typeNumber);
129 if (fuzzData.GetData<bool>()) {
130 if (!dataTemp.WriteParcelable(&info)) {
131 return false;
132 }
133 }
134
135 AAFwk::WantParams workParams;
136 if (fuzzData.GetData<bool>()) {
137 if (!dataTemp.WriteParcelable(&workParams)) {
138 return false;
139 }
140 }
141
142 auto testCallback = new TestGetDomainAccountInfoCallback();
143
144 if (testCallback == nullptr) {
145 return false;
146 }
147 if (fuzzData.GetData<bool>()) {
148 if (!dataTemp.WriteRemoteObject(testCallback->AsObject())) {
149 return false;
150 }
151 }
152
153 MessageParcel reply;
154 MessageOption option;
155 uint32_t code = static_cast<uint32_t>(IDomainAccountIpcCode::COMMAND_GET_ACCESS_TOKEN);
156 auto domainAccountService = std::make_shared<DomainAccountManagerService>();
157 domainAccountService->OnRemoteRequest(code, dataTemp, reply, option);
158
159 return true;
160 }
161
ProcUpdateAccountTokenStubFuzzTest(const uint8_t * data,size_t size)162 bool ProcUpdateAccountTokenStubFuzzTest(const uint8_t *data, size_t size)
163 {
164 if ((data == nullptr) || (size == 0)) {
165 return false;
166 }
167
168 MessageParcel dataTemp;
169 if (!dataTemp.WriteInterfaceToken(DomainAccountStub::GetDescriptor())) {
170 return false;
171 }
172
173 DomainAccountInfo info;
174 FuzzData fuzzData(data, size);
175 info.domain_ = fuzzData.GenerateString();
176 info.accountName_ = fuzzData.GenerateString();
177 info.accountId_ = fuzzData.GenerateString();
178 info.isAuthenticated = fuzzData.GenerateBool();
179 info.serverConfigId_ = fuzzData.GenerateString();
180 int typeNumber = fuzzData.GetData<int>() % ENUM_MAX;
181 info.status_ = static_cast<DomainAccountStatus>(typeNumber);
182 if (fuzzData.GetData<bool>()) {
183 if (!dataTemp.WriteParcelable(&info)) {
184 return false;
185 }
186 }
187 uint32_t bufferSize = fuzzData.GetData<bool>() ? TEST_VECTOR_MAX_SIZE : TOKEN_LEN;
188 if (!dataTemp.WriteInt32(bufferSize)) {
189 return false;
190 }
191 for (uint32_t i = 0; i < TOKEN_LEN; i++) {
192 if (!dataTemp.WriteUint8(fuzzData.GetData<uint8_t>())) {
193 return false;
194 }
195 }
196
197 MessageParcel reply;
198 MessageOption option;
199 uint32_t code = static_cast<uint32_t>(IDomainAccountIpcCode::COMMAND_UPDATE_ACCOUNT_TOKEN);
200 auto domainAccountService = std::make_shared<DomainAccountManagerService>();
201 domainAccountService->OnRemoteRequest(code, dataTemp, reply, option);
202
203 return true;
204 }
205 }
206
207 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)208 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
209 {
210 /* Run your code on data */
211 OHOS::ProcAddServerConfigStubFuzzTest(data, size);
212 OHOS::ProcGetAccountStatusStubFuzzTest(data, size);
213 OHOS::ProcGetDomainAccessTokenStubFuzzTest(data, size);
214 OHOS::ProcUpdateAccountTokenStubFuzzTest(data, size);
215 return 0;
216 }
217