1 /*
2 * Copyright (c) 2023-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 "activateosaccountstub_fuzzer.h"
17 #include <string>
18 #include <thread>
19 #include <vector>
20
21 #include "fuzz_data.h"
22 #include "ios_account.h"
23 #include "os_account_info_json_parser.h"
24 #include "os_account_manager_service.h"
25
26 using namespace std;
27 using namespace OHOS::AccountSA;
28 const int32_t MAX_TEST_ID = 10738; // Maximum test
29
30 namespace OHOS {
31 const int ENUM_TYPE_MAX = 5;
32 const int PRIVATE_NUMBER = 3;
33 const int END_NUMBER = 4;
34 const std::u16string IOS_ACCOUNT_DESCRIPTOR = u"ohos.accountfwk.IOsAccount";
ActivateOsAccountStubFuzzTest(const uint8_t * data,size_t size)35 bool ActivateOsAccountStubFuzzTest(const uint8_t *data, size_t size)
36 {
37 if ((data == nullptr) || (size == 0)) {
38 return false;
39 }
40
41 MessageParcel datas;
42 FuzzData fuzzData(data, size);
43 datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR);
44 int32_t testId = fuzzData.GetData<bool>() ?
45 (fuzzData.GetData<int32_t>() % MAX_TEST_ID) : fuzzData.GetData<int32_t>();
46 if (!datas.WriteInt32(testId)) {
47 return false;
48 }
49
50 MessageParcel reply;
51 MessageOption option;
52 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
53 osAccountManagerService_ ->OnRemoteRequest(
54 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_ACTIVATE_OS_ACCOUNT), datas, reply, option);
55
56 return true;
57 }
58
ProcCreateOsAccountWithFullInfoStubFuzzTest(const uint8_t * data,size_t size)59 bool ProcCreateOsAccountWithFullInfoStubFuzzTest(const uint8_t *data, size_t size)
60 {
61 if ((data == nullptr) || (size == 0)) {
62 return false;
63 }
64
65 MessageParcel datas;
66 if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
67 return false;
68 }
69
70 FuzzData fuzzData(data, size);
71
72 OsAccountInfo osAccountInfo;
73 osAccountInfo.SetLocalId(fuzzData.GetData<int>());
74 osAccountInfo.SetLocalName(fuzzData.GenerateString());
75 osAccountInfo.SetShortName(fuzzData.GenerateString());
76 int typeNumber = fuzzData.GetData<int>() % ENUM_TYPE_MAX;
77 if (typeNumber == PRIVATE_NUMBER) {
78 osAccountInfo.SetType(PRIVATE);
79 } else if (typeNumber == END_NUMBER) {
80 osAccountInfo.SetType(END);
81 } else {
82 OsAccountType testType = static_cast<OsAccountType>(typeNumber);
83 osAccountInfo.SetType(testType);
84 }
85 osAccountInfo.SetSerialNumber(fuzzData.GetData<int64_t>());
86
87 if (!datas.WriteParcelable(&osAccountInfo)) {
88 return false;
89 }
90
91 MessageParcel reply;
92 MessageOption option;
93 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
94 osAccountManagerService_->OnRemoteRequest(
95 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_CREATE_OS_ACCOUNT_WITH_FULL_INFO), datas, reply, option);
96 osAccountManagerService_->OnRemoteRequest(
97 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_CREATE_OS_ACCOUNT_WITH_FULL_INFO_IN_OSACCOUNTINFO),
98 datas, reply, option);
99 return true;
100 }
101
ProcGetCreatedOsAccountNumFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)102 bool ProcGetCreatedOsAccountNumFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
103 {
104 if ((data == nullptr) || (size == 0)) {
105 return false;
106 }
107
108 MessageParcel datas;
109 if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
110 return false;
111 }
112
113 FuzzData fuzzData(data, size);
114 if (!datas.WriteString(fuzzData.GenerateString())) {
115 return false;
116 }
117
118 MessageParcel reply;
119 MessageOption option;
120 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
121 osAccountManagerService_->OnRemoteRequest(static_cast<int32_t>(
122 IOsAccountIpcCode::COMMAND_GET_CREATED_OS_ACCOUNT_NUM_FROM_DATABASE), datas, reply, option);
123
124 return true;
125 }
126
ProcGetMaxAllowCreateIdFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)127 bool ProcGetMaxAllowCreateIdFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
128 {
129 if ((data == nullptr) || (size == 0)) {
130 return false;
131 }
132
133 MessageParcel datas;
134 if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
135 return false;
136 }
137
138 FuzzData fuzzData(data, size);
139 if (!datas.WriteString(fuzzData.GenerateString())) {
140 return false;
141 }
142
143 MessageParcel reply;
144 MessageOption option;
145 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
146 osAccountManagerService_->OnRemoteRequest(
147 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_MAX_ALLOW_CREATE_ID_FROM_DATABASE), datas, reply, option);
148
149 return true;
150 }
151
ProcGetOsAccountFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)152 bool ProcGetOsAccountFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
153 {
154 if ((data == nullptr) || (size == 0)) {
155 return false;
156 }
157
158 MessageParcel datas;
159 if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
160 return false;
161 }
162
163 FuzzData fuzzData(data, size);
164 if (!datas.WriteString(fuzzData.GenerateString())) {
165 return false;
166 }
167
168 if (!datas.WriteInt32(fuzzData.GetData<int32_t>())) {
169 return false;
170 }
171
172 MessageParcel reply;
173 MessageOption option;
174 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
175 osAccountManagerService_->OnRemoteRequest(
176 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_OS_ACCOUNT_FROM_DATABASE), datas, reply, option);
177
178 return true;
179 }
180
ProcGetOsAccountListFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)181 bool ProcGetOsAccountListFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
182 {
183 if ((data == nullptr) || (size == 0)) {
184 return false;
185 }
186
187 MessageParcel datas;
188 if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
189 return false;
190 }
191
192 FuzzData fuzzData(data, size);
193 if (!datas.WriteString(fuzzData.GenerateString())) {
194 return false;
195 }
196
197 MessageParcel reply;
198 MessageOption option;
199 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
200 osAccountManagerService_->OnRemoteRequest(
201 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_OS_ACCOUNT_LIST_FROM_DATABASE), datas, reply, option);
202
203 return true;
204 }
205
ProcGetSerialNumberFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)206 bool ProcGetSerialNumberFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
207 {
208 if ((data == nullptr) || (size == 0)) {
209 return false;
210 }
211
212 MessageParcel datas;
213 if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
214 return false;
215 }
216
217 FuzzData fuzzData(data, size);
218 if (!datas.WriteString(fuzzData.GenerateString())) {
219 return false;
220 }
221
222 MessageParcel reply;
223 MessageOption option;
224 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
225 osAccountManagerService_->OnRemoteRequest(
226 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_SERIAL_NUMBER_FROM_DATABASE), datas, reply, option);
227
228 return true;
229 }
230
ReadOsAccountInfo(MessageParcel & data,OsAccountInfo & accountInfo)231 bool ReadOsAccountInfo(MessageParcel &data, OsAccountInfo &accountInfo)
232 {
233 StringRawData stringRawData;
234
235 data.ReadInt32();
236 if (!data.ReadUint32(stringRawData.size)) {
237 return false;
238 }
239 auto readstringRawData = data.ReadRawData(stringRawData.size);
240 if (readstringRawData == nullptr) {
241 return false;
242 }
243 ErrCode stringRawDataoutError = stringRawData.RawDataCpy(readstringRawData);
244 if (stringRawDataoutError) {
245 return false;
246 }
247
248 std::string accountStr;
249 stringRawData.Unmarshalling(accountStr);
250 auto jsonObject = CreateJsonFromString(accountStr);
251 if (jsonObject == nullptr) {
252 return false;
253 }
254 FromJson(jsonObject.get(), accountInfo);
255 return true;
256 }
257
SendRequestWithCode(int32_t code)258 void SendRequestWithCode(int32_t code)
259 {
260 MessageParcel datas;
261 datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR);
262 MessageOption option;
263 MessageParcel reply;
264 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
265 osAccountManagerService_->OnRemoteRequest(code, datas, reply, option);
266 }
267
CheckOsAccountStatus()268 void CheckOsAccountStatus()
269 {
270 OsAccountInfo osAccountInfoOne;
271 OsAccountType testType = OsAccountType::NORMAL;
272 std::string accountName = "activateosaccountstub_test_account";
273 MessageParcel data;
274 MessageParcel reply;
275 MessageOption option;
276 data.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR);
277 data.WriteString16(Str8ToStr16(accountName));
278 data.WriteInt32(static_cast<int32_t>(testType));
279 auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
280 osAccountManagerService_->OnRemoteRequest(
281 static_cast<int32_t>(IOsAccountIpcCode::COMMAND_CREATE_OS_ACCOUNT), data, reply, option);
282 if (!ReadOsAccountInfo(reply, osAccountInfoOne)) {
283 return;
284 }
285 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_DEFAULT_ACTIVATED_OS_ACCOUNT));
286 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_BACKGROUND_OS_ACCOUNT_LOCAL_IDS));
287 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_OS_ACCOUNT_LOCAL_ID_FROM_PROCESS));
288 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_OS_ACCOUNT_SWITCH_MOD));
289 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_GET_OS_ACCOUNT_TYPE_FROM_PROCESS));
290 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_QUERY_ACTIVE_OS_ACCOUNT_IDS));
291 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_QUERY_ALL_CREATED_OS_ACCOUNTS));
292 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_QUERY_MAX_LOGGED_IN_OS_ACCOUNT_NUMBER));
293 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_IS_MAIN_OS_ACCOUNT));
294 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_IS_MULTI_OS_ACCOUNT_ENABLE));
295 SendRequestWithCode(static_cast<int32_t>(IOsAccountIpcCode::COMMAND_DEACTIVATE_ALL_OS_ACCOUNTS));
296 }
297 } // namespace OHOS
298
LLVMFuzzerInitialize(int * argc,char *** argv)299 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
300 {
301 OHOS::CheckOsAccountStatus();
302 return 0;
303 }
304
305 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)306 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
307 {
308 /* Run your code on data */
309 OHOS::ActivateOsAccountStubFuzzTest(data, size);
310 OHOS::ProcGetCreatedOsAccountNumFromDatabaseStubFuzzTest(data, size);
311 OHOS::ProcCreateOsAccountWithFullInfoStubFuzzTest(data, size);
312 OHOS::ProcGetMaxAllowCreateIdFromDatabaseStubFuzzTest(data, size);
313 OHOS::ProcGetOsAccountFromDatabaseStubFuzzTest(data, size);
314 OHOS::ProcGetOsAccountListFromDatabaseStubFuzzTest(data, size);
315 OHOS::ProcGetSerialNumberFromDatabaseStubFuzzTest(data, size);
316 return 0;
317 }
318