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