1 /*
2 * Copyright (c) 2024 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 "enterprise_device_mgr_ability_fuzzer.h"
17
18 #include "common_event_data.h"
19 #include "common_fuzzer.h"
20 #include "edm_ipc_interface_code.h"
21 #include "func_code.h"
22 #include "get_data_template.h"
23 #include "message_parcel.h"
24 #define protected public
25 #define private public
26 #include "enterprise_device_mgr_ability.h"
27 #undef protected
28 #undef private
29 #include "ienterprise_device_mgr.h"
30 #include "user_policy_manager.h"
31 #include "permission_checker.h"
32 #include "securec.h"
33 #include "utils.h"
34
35 namespace OHOS {
36 namespace EDM {
37 constexpr size_t MIN_SIZE = 64;
38 const std::string FIRMWARE_EVENT_INFO_NAME = "version";
39 const std::string FIRMWARE_EVENT_INFO_TYPE = "packageType";
40 const std::string FIRMWARE_EVENT_INFO_CHECK_TIME = "firstReceivedTime";
41
getCommonEventData(const uint8_t * data,size_t size)42 EventFwk::CommonEventData getCommonEventData(const uint8_t* data, size_t size)
43 {
44 int32_t pos = 0;
45 EventFwk::CommonEventData eventData;
46 EventFwk::Want want;
47 AppExecFwk::ElementName admin;
48 int32_t code = CommonFuzzer::GetU32Data(data, pos, size);
49 int uid = CommonFuzzer::GetU32Data(data, pos, size);
50 long checkTime = CommonFuzzer::GetLong(data, pos, size);
51 int32_t stringSize = (size - pos) / 5;
52 admin.SetBundleName(CommonFuzzer::GetString(data, pos, stringSize, size));
53 admin.SetAbilityName(CommonFuzzer::GetString(data, pos, stringSize, size));
54 eventData.SetCode(code);
55 want.SetParam(FIRMWARE_EVENT_INFO_NAME, CommonFuzzer::GetString(data, pos, stringSize, size));
56 want.SetParam(FIRMWARE_EVENT_INFO_TYPE, CommonFuzzer::GetString(data, pos, stringSize, size));
57 want.SetParam(FIRMWARE_EVENT_INFO_CHECK_TIME, checkTime);
58 want.SetParam(AppExecFwk::Constants::USER_ID, uid);
59 want.SetAction(CommonFuzzer::GetString(data, pos, stringSize, size));
60 eventData.SetWant(want);
61 want.SetElement(admin);
62 return eventData;
63 }
64
InitAdminParam(Admin & admin,std::string fuzzString,EntInfo entInfo,ManagedEvent event)65 void InitAdminParam(Admin &admin, std::string fuzzString, EntInfo entInfo, ManagedEvent event)
66 {
67 AdminInfo fuzzAdminInfo;
68 fuzzAdminInfo.packageName_ = fuzzString;
69 fuzzAdminInfo.className_ = fuzzString;
70 fuzzAdminInfo.entInfo_ = entInfo;
71 fuzzAdminInfo.permission_ = { fuzzString };
72 fuzzAdminInfo.managedEvents_ = { event };
73 fuzzAdminInfo.parentAdminName_ = fuzzString;
74 admin.adminInfo_ = fuzzAdminInfo;
75 }
76
77 // Fuzzer entry point.
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)78 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
79 {
80 if (data == nullptr) {
81 return 0;
82 }
83 if (size < MIN_SIZE) {
84 return 0;
85 }
86 g_data = data;
87 g_size = size;
88 g_pos = 0;
89 int32_t pos = 0;
90 int32_t stringSize = (size - pos) / 5;
91
92 TEST::Utils::SetEdmInitialEnv();
93 sptr<EnterpriseDeviceMgrAbility> enterpriseDeviceMgrAbility = EnterpriseDeviceMgrAbility::GetInstance();
94 enterpriseDeviceMgrAbility->OnStart();
95 EventFwk::CommonEventData eventData = getCommonEventData(data, size);
96
97 enterpriseDeviceMgrAbility->OnCommonEventSystemUpdate(eventData);
98 enterpriseDeviceMgrAbility->OnCommonEventUserRemoved(eventData);
99 enterpriseDeviceMgrAbility->OnCommonEventPackageAdded(eventData);
100 enterpriseDeviceMgrAbility->OnCommonEventPackageRemoved(eventData);
101 int32_t systemAbilityId = CommonFuzzer::GetU32Data(data);
102 const std::string deviceId(reinterpret_cast<const char*>(data), size);
103 enterpriseDeviceMgrAbility->OnAddSystemAbility(systemAbilityId, deviceId);
104 enterpriseDeviceMgrAbility->OnAppManagerServiceStart();
105 enterpriseDeviceMgrAbility->OnAbilityManagerServiceStart();
106 enterpriseDeviceMgrAbility->OnCommonEventServiceStart();
107
108 int32_t userId = CommonFuzzer::GetU32Data(data);
109 int32_t accountId = CommonFuzzer::GetU32Data(data);
110 int32_t interfaceCode = CommonFuzzer::GetU32Data(data);
111 enterpriseDeviceMgrAbility->SubscribeAppState();
112 enterpriseDeviceMgrAbility->UnsubscribeAppState();
113 AppExecFwk::ElementName admin;
114 std::string fuzzString(reinterpret_cast<const char*>(data), size);
115 admin.SetBundleName(fuzzString);
116 admin.SetAbilityName(fuzzString);
117 AdminType type = GetData<AdminType>();
118 bool isDebug = CommonFuzzer::GetU32Data(data) % BINARY_DECISION_DIVISOR;
119 enterpriseDeviceMgrAbility->VerifyEnableAdminCondition(admin, type, userId, isDebug);
120 std::string adminName(reinterpret_cast<const char*>(data), size);
121 const std::string policyName(reinterpret_cast<const char*>(data), size);
122 const std::string policyValue(reinterpret_cast<const char*>(data), size);
123 enterpriseDeviceMgrAbility->RemoveAdminItem(adminName, policyName, policyValue, userId);
124 std::string bundleName(reinterpret_cast<const char*>(data), size);
125 TEST::Utils::ResetTokenTypeAndUid();
126 PluginManager::GetInstance()->DumpPlugin();
127
128 std::string abilityName = CommonFuzzer::GetString(data, pos, stringSize, size);
129 std::string newAdminName = CommonFuzzer::GetString(data, pos, stringSize, size);
130 uint32_t code = CommonFuzzer::GetU32Data(data);
131 bool isAdminEnabled = CommonFuzzer::GetU32Data(data) % 2;
132 bool isModeOn = CommonFuzzer::GetU32Data(data) % 2;
133 bool isByod = CommonFuzzer::GetU32Data(data) % 2;
134 std::vector<std::u16string> args;
135 std::vector<std::string> policies;
136 Admin edmAdmin;
137 ManagedEvent event = GetData<ManagedEvent>();
138 EntInfo entInfo;
139 entInfo.enterpriseName = fuzzString;
140 entInfo.description = fuzzString;
141 InitAdminParam(edmAdmin, fuzzString, entInfo, event);
142 std::shared_ptr<Admin> adminPtr = std::make_shared<Admin>(edmAdmin);
143 enterpriseDeviceMgrAbility->OnCommonEventUserAdded(eventData);
144 enterpriseDeviceMgrAbility->OnCommonEventUserSwitched(eventData);
145 enterpriseDeviceMgrAbility->OnCommonEventPackageChanged(eventData);
146 enterpriseDeviceMgrAbility->OnCommonEventBmsReady(eventData);
147 enterpriseDeviceMgrAbility->OnCommonEventKioskMode(eventData, isModeOn);
148 enterpriseDeviceMgrAbility->OnAdminEnabled(bundleName, abilityName, code, userId, isAdminEnabled);
149 enterpriseDeviceMgrAbility->AddDisallowUninstallApp(bundleName, userId);
150 enterpriseDeviceMgrAbility->UpdateClipboardInfo(bundleName, userId);
151 enterpriseDeviceMgrAbility->DelDisallowUninstallApp(bundleName);
152 enterpriseDeviceMgrAbility->HandleKeepPolicy(adminName, newAdminName, edmAdmin, adminPtr);
153 enterpriseDeviceMgrAbility->AfterEnableAdmin(admin, type, userId);
154 enterpriseDeviceMgrAbility->RemoveAdminAndAdminPolicy(adminName, userId);
155 enterpriseDeviceMgrAbility->RemoveAdmin(adminName, userId);
156 enterpriseDeviceMgrAbility->RemoveAdminPolicy(adminName, userId);
157 enterpriseDeviceMgrAbility->RemoveSubSuperAdminAndAdminPolicy(bundleName);
158 enterpriseDeviceMgrAbility->RemoveSuperAdminAndAdminPolicy(bundleName);
159 enterpriseDeviceMgrAbility->CheckDelegatedPolicies(adminPtr, policies);
160 enterpriseDeviceMgrAbility->CheckRunningMode(code);
161 enterpriseDeviceMgrAbility->CheckManagedEvent(code);
162 enterpriseDeviceMgrAbility->ConnectAbility(accountId, adminPtr);
163 enterpriseDeviceMgrAbility->ConnectAbilityOnSystemAccountEvent(accountId, event);
164 enterpriseDeviceMgrAbility->ConnectAbilityOnSystemEvent(bundleName, event, userId);
165 enterpriseDeviceMgrAbility->CallOnOtherServiceStart(interfaceCode);
166 enterpriseDeviceMgrAbility->CallOnOtherServiceStart(interfaceCode, systemAbilityId);
167 enterpriseDeviceMgrAbility->IsByodAdmin(admin, isByod);
168 enterpriseDeviceMgrAbility->SetDelegatedPolicies(bundleName, policies, userId);
169 enterpriseDeviceMgrAbility->SetDelegatedPolicies(admin, bundleName, policies);
170 UserPolicyManager userPolicyMgr(0);
171 PolicyItemsMap itemMap;
172 itemMap[adminName] = fuzzString;
173 userPolicyMgr.GetAllPolicyByAdmin(adminName, itemMap);
174 userPolicyMgr.DeleteCombinedPolicy(fuzzString);
175 userPolicyMgr.ReplacePolicyByAdminName(0, adminName, fuzzString);
176 userPolicyMgr.DumpAdminPolicy();
177 userPolicyMgr.DumpAdminList();
178 userPolicyMgr.DumpCombinedPolicy();
179 PermissionChecker::GetInstance()->CheckCallerPermission(adminPtr, fuzzString, isAdminEnabled);
180 PermissionChecker::GetInstance()->CheckCallingUid(fuzzString);
181 PermissionChecker::GetInstance()->GetAllPermissionsByAdmin(fuzzString, type, userId, policies);
182 FuncOperateType fType = GetData<FuncOperateType>();
183 PermissionChecker::GetInstance()->CheckHandlePolicyPermission(fType, bundleName, fuzzString, fuzzString, userId);
184 PermissionChecker::GetInstance()->CheckAndUpdatePermission(adminPtr, 0, fuzzString, userId);
185 PermissionChecker::GetInstance()->GetCurrentUserId();
186 PermissionChecker::GetInstance()->CheckSpecialPolicyCallQuery(userId);
187 return 0;
188 }
189 } // namespace EDM
190 } // namespace OHOS