1 /*
2 * Copyright (c) 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 <cstddef>
17 #include <cstdint>
18 #include <set>
19 #include <fuzzer/FuzzedDataProvider.h>
20
21 #include "bundle_mgr_proxy.h"
22
23 #include "bmsbundlemgrproxypartone_fuzzer.h"
24 #include "bms_fuzztest_util.h"
25
26 using Want = OHOS::AAFwk::Want;
27
28 using namespace OHOS::AppExecFwk;
29 using namespace OHOS::AppExecFwk::BMSFuzzTestUtil;
30 namespace OHOS {
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)31 bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
32 {
33 sptr<IRemoteObject> object;
34 BundleMgrProxy bundleMgrProxy(object);
35 FuzzedDataProvider fdp(data, size);
36 std::string bundleName = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
37 BundleInfo bundleInfo;
38 GenerateBundleInfo(fdp, bundleInfo);
39 std::vector<BundleInfo> bundleInfos;
40 bundleMgrProxy.QueryKeepAliveBundleInfos(bundleInfos);
41
42 sptr<IBundleStatusCallback> bundleStatusCallback;
43 bundleMgrProxy.RegisterBundleStatusCallback(bundleStatusCallback);
44 bundleMgrProxy.ClearBundleStatusCallback(bundleStatusCallback);
45
46 DumpFlag dumpFlag = static_cast<DumpFlag>(fdp.ConsumeIntegralInRange<uint8_t>(1, 4));
47 int32_t userId = GenerateRandomUser(fdp);
48 std::string result = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
49 bundleMgrProxy.DumpInfos(dumpFlag, bundleName, userId, result);
50
51 bool isEnable = fdp.ConsumeBool();
52 bundleMgrProxy.IsApplicationEnabled(bundleName, isEnable);
53 bundleMgrProxy.SetApplicationEnabled(bundleName, isEnable, userId);
54
55 AbilityInfo abilityInfo;
56 GenerateAbilityInfo<AbilityInfo>(fdp, abilityInfo);
57 bundleMgrProxy.IsAbilityEnabled(abilityInfo, isEnable);
58 bundleMgrProxy.SetAbilityEnabled(abilityInfo, isEnable, reinterpret_cast<uintptr_t>(data));
59
60 FormInfo formInfo;
61 formInfo.bundleName = bundleName;
62 std::vector<FormInfo> formInfos;
63 formInfos.push_back(formInfo);
64 bundleMgrProxy.GetAllFormsInfo(formInfos);
65 bundleMgrProxy.GetFormsInfoByApp(bundleName, formInfos);
66 std::string moduleName = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
67 bundleMgrProxy.GetFormsInfoByModule(bundleName, moduleName, formInfos);
68
69 std::vector<ShortcutInfo> shortcutInfos;
70 bundleMgrProxy.GetShortcutInfos(bundleName, shortcutInfos);
71 bundleMgrProxy.GetShortcutInfoV9(bundleName, shortcutInfos);
72
73 std::string eventKey = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
74 std::vector<CommonEventInfo> commonEventInfos;
75 bundleMgrProxy.GetAllCommonEventInfo(eventKey, commonEventInfos);
76
77 std::string networkId = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
78 DistributedBundleInfo distributedBundleInfo;
79 bundleMgrProxy.GetDistributedBundleInfo(networkId, bundleName, distributedBundleInfo);
80 bundleMgrProxy.GetAppPrivilegeLevel(bundleName, reinterpret_cast<uintptr_t>(data));
81
82 Want want;
83 want.SetAction(bundleName);
84 ExtensionAbilityInfo extensionInfo;
85 std::vector<ExtensionAbilityInfo> extensionInfos;
86 int32_t flag = fdp.ConsumeIntegral<int32_t>();
87 bundleMgrProxy.QueryExtensionAbilityInfos(want, userId, flag, extensionInfos);
88 bundleMgrProxy.QueryExtensionAbilityInfosV9(want, userId, flag, extensionInfos);
89 ExtensionAbilityType extensionType =
90 static_cast<ExtensionAbilityType>(fdp.ConsumeIntegralInRange<uint8_t>(0, 24));
91 bundleMgrProxy.QueryExtensionAbilityInfos(want, extensionType, userId, flag, extensionInfos);
92 bundleMgrProxy.QueryExtensionAbilityInfosV9(want, extensionType, userId, flag, extensionInfos);
93 bundleMgrProxy.QueryExtensionAbilityInfos(extensionType, flag, extensionInfos);
94 std::string permission = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
95 bundleMgrProxy.VerifyCallingPermission(permission);
96 std::string uri = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
97 bundleMgrProxy.QueryExtensionAbilityInfoByUri(uri, userId, extensionInfo);
98 bundleMgrProxy.ImplicitQueryInfoByPriority(want, userId, flag, abilityInfo, extensionInfo);
99
100 abilityInfo.name = bundleName;
101 std::vector<AbilityInfo> abilityInfos;
102 abilityInfos.push_back(abilityInfo);
103 bool findDafaultApp = fdp.ConsumeBool();
104 bool withDefault = fdp.ConsumeBool();
105 bundleMgrProxy.ImplicitQueryInfos(
106 want, flag, userId, withDefault, abilityInfos, extensionInfos, findDafaultApp);
107
108 std::string abilityName = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
109 bundleMgrProxy.GetAbilityInfo(bundleName, abilityName, abilityInfo);
110 bundleMgrProxy.GetAbilityInfo(bundleName, moduleName, abilityName, abilityInfo);
111 BundleInfo info;
112 int32_t appIndex = fdp.ConsumeIntegral<int32_t>();
113 bundleMgrProxy.GetSandboxBundleInfo(bundleName, appIndex, userId, info);
114 bundleMgrProxy.IsModuleRemovable(bundleName, moduleName, isEnable);
115 bundleMgrProxy.SetModuleRemovable(bundleName, moduleName, isEnable);
116 std::vector<std::string> dependentModuleNames;
117 bundleMgrProxy.GetAllDependentModuleNames(bundleName, moduleName, dependentModuleNames);
118 bundleMgrProxy.GetModuleUpgradeFlag(bundleName, moduleName);
119 int32_t upgradeFlag = fdp.ConsumeIntegral<int32_t>();
120 bundleMgrProxy.SetModuleUpgradeFlag(bundleName, moduleName, upgradeFlag);
121 bundleMgrProxy.ObtainCallingBundleName(bundleName);
122 std::vector<int64_t> bundleStats;
123 bundleMgrProxy.GetBundleStats(bundleName, userId, bundleStats);
124 sptr<IRemoteObject> callback;
125 int32_t missionId = fdp.ConsumeIntegral<int32_t>();
126 bundleMgrProxy.CheckAbilityEnableInstall(want, missionId, userId, callback);
127 std::unique_ptr<uint8_t[]> mediaDataPtr;
128 bundleMgrProxy.GetMediaData(bundleName, moduleName, abilityName, mediaDataPtr, size, userId);
129 uint32_t resId = fdp.ConsumeIntegral<uint32_t>();
130 std::string localeInfo = fdp.ConsumeRandomLengthString(STRING_MAX_LENGTH);
131 bundleMgrProxy.GetStringById(bundleName, moduleName, resId, userId, localeInfo);
132 uint32_t density = fdp.ConsumeIntegral<uint32_t>();
133 bundleMgrProxy.GetIconById(bundleName, moduleName, resId, density, userId);
134 bundleMgrProxy.GetSandboxAbilityInfo(want, appIndex, flag, userId, abilityInfo);
135 bundleMgrProxy.GetSandboxExtAbilityInfos(want, appIndex, flag, userId, extensionInfos);
136 HapModuleInfo hapModuleInfo;
137 bundleMgrProxy.GetSandboxHapModuleInfo(abilityInfo, appIndex, userId, hapModuleInfo);
138 bundleMgrProxy.UnregisterBundleStatusCallback();
139 bundleMgrProxy.GetBundleInstaller();
140 bundleMgrProxy.GetBundleUserMgr();
141 bundleMgrProxy.GetQuickFixManagerProxy();
142 bundleMgrProxy.GetAppControlProxy();
143
144 ApplicationInfo appInfo;
145 bundleMgrProxy.GetApplicationInfo(bundleName, flag, userId, appInfo);
146 bundleMgrProxy.GetApplicationInfo(bundleName, flag, userId, appInfo);
147 bundleMgrProxy.GetApplicationInfoV9(bundleName, flag, userId, appInfo);
148 std::vector<ApplicationInfo> appInfos;
149 bundleMgrProxy.GetApplicationInfos(flag, userId, appInfos);
150 bundleMgrProxy.GetApplicationInfos(flag, userId, appInfos);
151 bundleMgrProxy.GetApplicationInfosV9(flag, userId, appInfos);
152 bundleMgrProxy.GetBundleInfo(bundleName, flag, bundleInfo, userId);
153 bundleMgrProxy.GetBundleInfo(bundleName, flag, bundleInfo, userId);
154 bundleMgrProxy.GetBundleInfoV9(bundleName, flag, bundleInfo, userId);
155 return true;
156 }
157 }
158
159 // Fuzzer entry point.
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)160 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
161 {
162 // Run your code on data.
163 OHOS::DoSomethingInterestingWithMyAPI(data, size);
164 return 0;
165 }