1 /*
2 * Copyright (c) 2023 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 <unistd.h>
17 #include <thread>
18
19 #include "accesstoken_kit.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22
23 #include "link.h"
24
25 #include "udmf_fuzzer.h"
26 #include "udmf.h"
27 #include "udmf_capi_common.h"
28 #include "udmf_meta.h"
29
30 using namespace OHOS;
31 using namespace OHOS::Security::AccessToken;
32 using namespace OHOS::UDMF;
33
34 namespace OHOS {
35 static constexpr int END_INTERVAL = 3;
36
AllocHapToken()37 void AllocHapToken()
38 {
39 HapInfoParams info = {
40 .userID = 100,
41 .bundleName = "ohos.test.demo",
42 .instIndex = 0,
43 .appIDDesc = "ohos.test.demo"
44 };
45
46 HapPolicyParams policy = {
47 .apl = APL_NORMAL,
48 .domain = "test.domain",
49 .permList = {
50 {
51 .permissionName = "ohos.permission.test",
52 .bundleName = "ohos.test.demo",
53 .grantMode = 1,
54 .availableLevel = APL_NORMAL,
55 .label = "label",
56 .labelId = 1,
57 .description = "test",
58 .descriptionId = 1
59 }
60 },
61 .permStateList = {
62 {
63 .permissionName = "ohos.permission.test",
64 .isGeneral = true,
65 .resDeviceID = {"local"},
66 .grantStatus = {PermissionState::PERMISSION_GRANTED},
67 .grantFlags = {1}
68 }
69 }
70 };
71 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
72 SetSelfTokenID(tokenID.tokenIDEx);
73 }
74
SetUpTestCase()75 void SetUpTestCase()
76 {
77 AllocHapToken();
78 }
79
TearDown()80 void TearDown()
81 {
82 std::this_thread::sleep_for(std::chrono::seconds(END_INTERVAL));
83 }
84
SetNativeToken()85 void SetNativeToken()
86 {
87 NativeTokenInfoParams infoInstance = {
88 .dcapsNum = 0,
89 .permsNum = 0,
90 .aclsNum = 0,
91 .dcaps = nullptr,
92 .perms = nullptr,
93 .acls = nullptr,
94 .processName = "msdp_sa",
95 .aplStr = "system_core",
96 };
97 auto tokenId = GetAccessTokenId(&infoInstance);
98 SetSelfTokenID(tokenId);
99 AccessTokenKit::ReloadNativeTokenInfo();
100 }
101
SetHapToken()102 void SetHapToken()
103 {
104 auto tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo", 0);
105 SetSelfTokenID(tokenId);
106 }
107
SetUnifiedDataFuzz(const uint8_t * data,size_t size)108 void SetUnifiedDataFuzz(const uint8_t *data, size_t size)
109 {
110 std::string skey(data, data + size);
111 OH_UdmfData *udmfUnifiedData = OH_UdmfData_Create();
112 OH_UdmfRecord *record = OH_UdmfRecord_Create();
113 OH_UdsFileUri *fileUri = OH_UdsFileUri_Create();
114 OH_UdsFileUri_SetFileUri(fileUri, skey.c_str());
115 OH_UdsFileUri_SetFileType(fileUri, UDMF_META_IMAGE);
116 OH_UdmfRecord_AddFileUri(record, fileUri);
117 OH_UdmfData_AddRecord(udmfUnifiedData, record);
118 OH_UdmfOptions* options = OH_UdmfOptions_Create();
119 options->intention = UDMF_INTENTION_DATA_HUB;
120 char key[UDMF_KEY_BUFFER_LEN];
121 OH_Udmf_SetUnifiedDataByOptions(options, udmfUnifiedData, key, UDMF_KEY_BUFFER_LEN);
122 OH_UdmfOptions_Destroy(options);
123 OH_UdsFileUri_Destroy(fileUri);
124 OH_UdmfRecord_Destroy(record);
125 OH_UdmfData_Destroy(udmfUnifiedData);
126 }
127
GetUnifiedDataFuzz(const uint8_t * data,size_t size)128 void GetUnifiedDataFuzz(const uint8_t *data, size_t size)
129 {
130 std::string skey(data, data + size);
131 OH_UdmfData *udmfUnifiedData = OH_UdmfData_Create();
132 OH_UdmfRecord *record = OH_UdmfRecord_Create();
133 OH_UdsFileUri *fileUri = OH_UdsFileUri_Create();
134 OH_UdsFileUri_SetFileUri(fileUri, skey.c_str());
135 OH_UdsFileUri_SetFileType(fileUri, UDMF_META_IMAGE);
136 OH_UdmfRecord_AddFileUri(record, fileUri);
137 OH_UdmfData_AddRecord(udmfUnifiedData, record);
138 OH_UdmfOptions* options = OH_UdmfOptions_Create();
139 options->intention = UDMF_INTENTION_DATA_HUB;
140 char key[UDMF_KEY_BUFFER_LEN];
141 OH_Udmf_SetUnifiedDataByOptions(options, udmfUnifiedData, key, UDMF_KEY_BUFFER_LEN);
142
143 unsigned int dataSize = 0;
144 OH_UdmfData* dataArray = nullptr;
145 OH_Udmf_GetUnifiedDataByOptions(options, &dataArray, &dataSize);
146 OH_UdmfOptions_Destroy(options);
147 OH_UdsFileUri_Destroy(fileUri);
148 OH_UdmfRecord_Destroy(record);
149 OH_UdmfData_Destroy(udmfUnifiedData);
150 OH_Udmf_DestroyDataArray(&dataArray, dataSize);
151 }
152
UpdataUnifiedDataFuzz(const uint8_t * data,size_t size)153 void UpdataUnifiedDataFuzz(const uint8_t *data, size_t size)
154 {
155 std::string skey(data, data + size);
156 OH_UdmfData *udmfUnifiedData = OH_UdmfData_Create();
157 OH_UdmfRecord *record = OH_UdmfRecord_Create();
158 OH_UdsFileUri *fileUri = OH_UdsFileUri_Create();
159 OH_UdsFileUri_SetFileUri(fileUri, skey.c_str());
160 OH_UdsFileUri_SetFileType(fileUri, UDMF_META_IMAGE);
161 OH_UdmfRecord_AddFileUri(record, fileUri);
162 OH_UdmfData_AddRecord(udmfUnifiedData, record);
163 OH_UdmfOptions* options = OH_UdmfOptions_Create();
164 options->intention = UDMF_INTENTION_DATA_HUB;
165 char key[UDMF_KEY_BUFFER_LEN];
166 OH_Udmf_SetUnifiedDataByOptions(options, udmfUnifiedData, key, UDMF_KEY_BUFFER_LEN);
167
168 std::string svalue(data, data + size);
169 OH_UdmfData *udmfUnifiedData2 = OH_UdmfData_Create();
170 OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
171 OH_UdsFileUri *fileUri2 = OH_UdsFileUri_Create();
172 OH_UdsFileUri_SetFileUri(fileUri2, svalue.c_str());
173 OH_UdsFileUri_SetFileType(fileUri2, UDMF_META_IMAGE);
174 OH_UdmfRecord_AddFileUri(record2, fileUri2);
175 OH_UdmfData_AddRecord(udmfUnifiedData2, record2);
176 OH_UdmfOptions* options2 = OH_UdmfOptions_Create();
177 options2->intention = UDMF_INTENTION_DATA_HUB;
178 options2->key = key;
179 OH_Udmf_UpdateUnifiedData(options2, udmfUnifiedData2);
180 OH_UdmfOptions_Destroy(options);
181 OH_UdmfOptions_Destroy(options2);
182 OH_UdsFileUri_Destroy(fileUri);
183 OH_UdsFileUri_Destroy(fileUri2);
184 OH_UdmfRecord_Destroy(record);
185 OH_UdmfRecord_Destroy(record2);
186 OH_UdmfData_Destroy(udmfUnifiedData);
187 OH_UdmfData_Destroy(udmfUnifiedData2);
188 }
189
DeleteUnifiedDataFuzz(const uint8_t * data,size_t size)190 void DeleteUnifiedDataFuzz(const uint8_t *data, size_t size)
191 {
192 std::string skey(data, data + size);
193 OH_UdmfData *udmfUnifiedData = OH_UdmfData_Create();
194 OH_UdmfRecord *record = OH_UdmfRecord_Create();
195 OH_UdsFileUri *fileUri = OH_UdsFileUri_Create();
196 OH_UdsFileUri_SetFileUri(fileUri, skey.c_str());
197 OH_UdsFileUri_SetFileType(fileUri, UDMF_META_IMAGE);
198 OH_UdmfRecord_AddFileUri(record, fileUri);
199 OH_UdmfData_AddRecord(udmfUnifiedData, record);
200 OH_UdmfOptions* options = OH_UdmfOptions_Create();
201 options->intention = UDMF_INTENTION_DATA_HUB;
202 char key[UDMF_KEY_BUFFER_LEN];
203 OH_Udmf_SetUnifiedDataByOptions(options, udmfUnifiedData, key, UDMF_KEY_BUFFER_LEN);
204
205 unsigned int dataSize = 0;
206 OH_UdmfData* dataArray = nullptr;
207 OH_Udmf_DeleteUnifiedData(options, &dataArray, &dataSize);
208 OH_UdmfOptions_Destroy(options);
209 OH_UdsFileUri_Destroy(fileUri);
210 OH_UdmfRecord_Destroy(record);
211 OH_UdmfData_Destroy(udmfUnifiedData);
212 OH_Udmf_DestroyDataArray(&dataArray, dataSize);
213 }
214
SetAndGetVisibilityFuzz(const uint8_t * data,size_t size)215 void SetAndGetVisibilityFuzz(const uint8_t *data, size_t size)
216 {
217 OH_UdmfOptions* options = OH_UdmfOptions_Create();
218 Udmf_Visibility testVisibility = Udmf_Visibility::UDMF_ALL;
219 OH_UdmfOptions_SetVisibility(options, testVisibility);
220 OH_UdmfOptions_GetVisibility(options);
221 OH_UdmfOptions_Destroy(options);
222 OH_UdmfOptions* options1 = OH_UdmfOptions_Create();
223 testVisibility = Udmf_Visibility::UDMF_OWN_PROCESS;
224 OH_UdmfOptions_SetVisibility(options1, testVisibility);
225 OH_UdmfOptions_GetVisibility(options1);
226 OH_UdmfOptions_Destroy(options1);
227 }
228 }
229
230 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)231 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
232 {
233 /* Run your code on data */
234 OHOS::SetUpTestCase();
235 OHOS::SetUnifiedDataFuzz(data, size);
236 OHOS::GetUnifiedDataFuzz(data, size);
237 OHOS::UpdataUnifiedDataFuzz(data, size);
238 OHOS::DeleteUnifiedDataFuzz(data, size);
239 OHOS::SetAndGetVisibilityFuzz(data, size);
240 OHOS::TearDown();
241 return 0;
242 }