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 "createosaccount_fuzzer.h"
17 
18 #include <cstdint>
19 #include <string>
20 #include <vector>
21 #include "os_account_manager.h"
22 #include "account_log_wrapper.h"
23 #include "fuzz_data.h"
24 #undef private
25 #include "os_account_constants.h"
26 #include "securec.h"
27 
28 using namespace std;
29 using namespace OHOS::AccountSA;
30 namespace OHOS {
31 const int CONSTANTS_NUMBER_FIVE = 5;
32 const int LIST_NUMBER_LIMIT = 1002;
33 const int HAP_NAME_LENGTH_LIMIT = 1000;
34 const uint8_t *g_baseFuzzData = nullptr;
35 size_t g_baseFuzzSize = 0;
36 size_t g_baseFuzzPos;
37 
GetData()38 template <class T> T GetData()
39 {
40     T object{};
41     size_t objectSize = sizeof(object);
42     if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
43         return object;
44     }
45     errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
46     if (ret != EOK) {
47         return {};
48     }
49     g_baseFuzzPos += objectSize;
50     return object;
51 }
52 
CreateOsAccountWithShortNameFuzzTest(const uint8_t * data,size_t size)53 bool CreateOsAccountWithShortNameFuzzTest(const uint8_t* data, size_t size)
54 {
55     bool result = false;
56     if ((data != nullptr) && (size != 0)) {
57         FuzzData fuzzData(data, size);
58         OsAccountInfo osAccountInfoOne;
59         OsAccountType testType = static_cast<OsAccountType>(fuzzData.GetData<uint32_t>() % CONSTANTS_NUMBER_FIVE);
60         std::string accountName(fuzzData.GenerateRandomString());
61         std::string shortName(fuzzData.GenerateRandomString());
62         result = OsAccountManager::CreateOsAccount(accountName, shortName, testType, osAccountInfoOne);
63         if (result == ERR_OK) {
64             ACCOUNT_LOGI("CreateOsAccountWithShortNameFuzzTest RemoveOsAccount");
65             OsAccountManager::RemoveOsAccount(osAccountInfoOne.GetLocalId());
66         }
67         uint32_t listSize = fuzzData.GetData<uint32_t>();
68         CreateOsAccountOptions options;
69         for (uint32_t i = 0; i < listSize % LIST_NUMBER_LIMIT; i++) {
70             uint32_t hapNameSize = fuzzData.GetData<uint32_t>();
71             std::string hapName(fuzzData.GetStringFromData(0, hapNameSize % HAP_NAME_LENGTH_LIMIT));
72             options.disallowedHapList.push_back(hapName);
73         }
74         result = OsAccountManager::CreateOsAccount(accountName, shortName, testType, options, osAccountInfoOne);
75         if (result == ERR_OK) {
76             ACCOUNT_LOGI("CreateOsAccountWithShortNameFuzzTest RemoveOsAccount");
77             OsAccountManager::RemoveOsAccount(osAccountInfoOne.GetLocalId());
78         }
79     }
80     return result;
81 }
82 
CreateOsAccountFuzzTest(const uint8_t * data,size_t size)83 bool CreateOsAccountFuzzTest(const uint8_t* data, size_t size)
84 {
85     bool result = false;
86     if ((data != nullptr) && (size != 0)) {
87         FuzzData fuzzData(data, size);
88         OsAccountInfo osAccountInfoOne;
89         OsAccountType testType = static_cast<OsAccountType>(fuzzData.GetData<uint32_t>() % CONSTANTS_NUMBER_FIVE);
90         std::string accountName(fuzzData.GenerateRandomString());
91         result = OsAccountManager::CreateOsAccount(accountName, testType, osAccountInfoOne);
92         if (result == ERR_OK) {
93             ACCOUNT_LOGI("CreateOsAccountFuzzTest RemoveOsAccount");
94             OsAccountManager::RemoveOsAccount(osAccountInfoOne.GetLocalId());
95         }
96     }
97     return result;
98 }
99 
CreateOsAccountForDomainFuzzTest(const uint8_t * data,size_t size)100 bool CreateOsAccountForDomainFuzzTest(const uint8_t* data, size_t size)
101 {
102     bool result = false;
103     if ((data != nullptr) && (size != 0)) {
104         FuzzData fuzzData(data, size);
105         std::string accountName(fuzzData.GenerateRandomString());
106         std::string domain(fuzzData.GenerateRandomString());
107         DomainAccountInfo domainInfo(accountName, domain);
108         OsAccountType testType = static_cast<OsAccountType>(fuzzData.GetData<uint32_t>() % CONSTANTS_NUMBER_FIVE);
109         OsAccountInfo osAccountInfo;
110         result = OsAccountManager::CreateOsAccountForDomain(testType, domainInfo, nullptr);
111         if (result == ERR_OK) {
112             ACCOUNT_LOGI("CreateOsAccountForDomainFuzzTest RemoveOsAccount");
113             OsAccountManager::RemoveOsAccount(osAccountInfo.GetLocalId());
114         }
115     }
116     return result;
117 }
118 
UpdateOsAccountWithFullInfoFuzzTest(const uint8_t * data,size_t size)119 bool UpdateOsAccountWithFullInfoFuzzTest(const uint8_t* data, size_t size)
120 {
121     bool result = false;
122     if ((data != nullptr) && (size != 0)) {
123         FuzzData fuzzData(data, size);
124         OsAccountInfo osAccountInfo;
125         osAccountInfo.SetLocalName(fuzzData.GenerateRandomString());
126         osAccountInfo.SetLocalId(fuzzData.GetData<int64_t>());
127         osAccountInfo.SetSerialNumber(fuzzData.GetData<int64_t>());
128         osAccountInfo.SetCreateTime(fuzzData.GetData<int64_t>());
129         osAccountInfo.SetLastLoginTime(fuzzData.GetData<int64_t>());
130         result = OsAccountManager::UpdateOsAccountWithFullInfo(osAccountInfo);
131         if (result == ERR_OK) {
132             ACCOUNT_LOGI("CreateOsAccountFuzzTest RemoveOsAccount");
133             OsAccountManager::RemoveOsAccount(osAccountInfo.GetLocalId());
134         }
135     }
136     return result;
137 }
138 
CreateOsAccountWithFullInfoFuzzTest(const uint8_t * data,size_t size)139 bool CreateOsAccountWithFullInfoFuzzTest(const uint8_t* data, size_t size)
140 {
141     bool result = false;
142     if ((data != nullptr) && (size != 0)) {
143         FuzzData fuzzData(data, size);
144         OsAccountInfo osAccountInfo;
145         osAccountInfo.SetLocalName(fuzzData.GenerateRandomString());
146         osAccountInfo.SetLocalId(fuzzData.GetData<int64_t>());
147         osAccountInfo.SetSerialNumber(fuzzData.GetData<int64_t>());
148         osAccountInfo.SetCreateTime(fuzzData.GetData<int64_t>());
149         osAccountInfo.SetLastLoginTime(fuzzData.GetData<int64_t>());
150         result = OsAccountManager::CreateOsAccountWithFullInfo(osAccountInfo);
151         if (result == ERR_OK) {
152             ACCOUNT_LOGI("CreateOsAccountFuzzTest RemoveOsAccount");
153             OsAccountManager::RemoveOsAccount(osAccountInfo.GetLocalId());
154         }
155     }
156     return result;
157 }
158 
CovWithoutParamFunctionFuzzTest(const uint8_t * data,size_t size)159 bool CovWithoutParamFunctionFuzzTest(const uint8_t* data, size_t size)
160 {
161     bool result = false;
162     if ((data != nullptr) && (size != 0)) {
163         std::string nameStr;
164         std::vector<ForegroundOsAccount> accounts;
165         std::vector<int32_t> localIds;
166         OsAccountManager::GetOsAccountShortName(nameStr);
167         OsAccountManager::GetOsAccountName(nameStr);
168         OsAccountManager::GetForegroundOsAccounts(accounts);
169         OsAccountManager::GetBackgroundOsAccountLocalIds(localIds);
170     }
171     return result;
172 }
173 
CheckOsAccountConstraintEnabledFuzzTest(const uint8_t * data,size_t size)174 bool CheckOsAccountConstraintEnabledFuzzTest(const uint8_t* data, size_t size)
175 {
176     bool result = false;
177     if ((data != nullptr) && (size != 0)) {
178         FuzzData fuzzData(data, size);
179         int32_t userId = fuzzData.GetData<int32_t>();
180         std::string constraintStr(fuzzData.GenerateRandomString());
181         bool isEnabled = false;
182         result = OsAccountManager::CheckOsAccountConstraintEnabled(userId, constraintStr, isEnabled);
183     }
184     return result;
185 }
186 } // namespace
187 
188 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)189 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
190 {
191     /* Run your code on data */
192     OHOS::CreateOsAccountWithShortNameFuzzTest(data, size);
193     OHOS::CreateOsAccountFuzzTest(data, size);
194     OHOS::CreateOsAccountForDomainFuzzTest(data, size);
195     OHOS::UpdateOsAccountWithFullInfoFuzzTest(data, size);
196     OHOS::CreateOsAccountWithFullInfoFuzzTest(data, size);
197     OHOS::CovWithoutParamFunctionFuzzTest(data, size);
198     OHOS::CheckOsAccountConstraintEnabledFuzzTest(data, size);
199     return 0;
200 }
201 
202