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 #include "hksipc_fuzzer.h"
16 
17 #include <cstring>
18 #include <securec.h>
19 #include <vector>
20 
21 #include "file_ex.h"
22 #include "hks_api.h"
23 #include "hks_log.h"
24 #include "hks_mem.h"
25 #include "hks_param.h"
26 #include "hks_service_ipc_serialization.h"
27 #include "hks_type.h"
28 #include "hks_type_inner.h"
29 
30 #include "hks_fuzz_util.h"
31 
32 namespace OHOS {
33 namespace Security {
34 namespace Hks {
35 
36 /**
37  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest001
38  * @tc.desc: tdd HksParamSetToParams, expect HKS_SUCCESS
39  * @tc.type: FUNC
40  */
HksIpcSerializationTest001()41 static void HksIpcSerializationTest001()
42 {
43     HKS_LOG_I("enter HksIpcSerializationTest001");
44     struct HksParamSet *paramSet = nullptr;
45     int32_t ret = HksInitParamSet(&paramSet);
46     const char *alias = "alias";
47     struct HksBlob aliasBlob = { .size = strlen(alias), .data = (uint8_t *)alias };
48     struct HksParam aliasParam = { .tag = HKS_TAG_ATTESTATION_ID_ALIAS, .blob = aliasBlob };
49     ret = HksAddParams(paramSet, &aliasParam, 1);
50     ret = HksBuildParamSet(&paramSet);
51     struct HksParamOut aliasOutParam = { .tag = HKS_TAG_ATTESTATION_ID_ALIAS, .blob = &aliasBlob };
52     ret = HksParamSetToParams(paramSet, &aliasOutParam, 1);
53     HksFreeParamSet(&paramSet);
54 }
55 
56 /**
57  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest002
58  * @tc.desc: tdd HksParamSetToParams, expect HKS_ERROR_PARAM_NOT_EXIST
59  * @tc.type: FUNC
60  */
HksIpcSerializationTest002()61 static void HksIpcSerializationTest002()
62 {
63     HKS_LOG_I("enter HksIpcSerializationTest002");
64     struct HksParamSet *paramSet = nullptr;
65     int32_t ret = HksInitParamSet(&paramSet);
66     const char *alias = "alias";
67     struct HksBlob aliasBlob = { .size = strlen(alias), .data = (uint8_t *)alias };
68     struct HksParamOut aliasOutParam = { .tag = HKS_TAG_ATTESTATION_ID_ALIAS, .blob = &aliasBlob };
69     ret = HksBuildParamSet(&paramSet);
70     ret = HksParamSetToParams(paramSet, &aliasOutParam, 1);
71     HksFreeParamSet(&paramSet);
72 }
73 
74 /**
75  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest003
76  * @tc.desc: tdd HksParamSetToParams, expect HKS_SUCCESS
77  * @tc.type: FUNC
78  */
HksIpcSerializationTest003()79 static void HksIpcSerializationTest003()
80 {
81     HKS_LOG_I("enter HksIpcSerializationTest003");
82     struct HksParamSet *paramSet = nullptr;
83     int32_t ret = HksInitParamSet(&paramSet);
84     const char *alias = "alias";
85     struct HksBlob aliasBlob = { .size = strlen(alias), .data = (uint8_t *)alias };
86     struct HksParamOut aliasOutParam = { .tag = HKS_TAG_ATTESTATION_ID_ALIAS, .blob = &aliasBlob };
87     struct HksParam aliasNullParam = { .tag = HKS_TAG_ATTESTATION_ID_ALIAS + HKS_PARAM_BUFFER_NULL_INTERVAL,
88         .blob = aliasBlob };
89     ret = HksAddParams(paramSet, &aliasNullParam, 1);
90     ret = HksBuildParamSet(&paramSet);
91     ret = HksParamSetToParams(paramSet, &aliasOutParam, 1);
92     HksFreeParamSet(&paramSet);
93 }
94 
95 /**
96  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest004
97  * @tc.desc: tdd HksParamSetToParams, expect HKS_SUCCESS
98  * @tc.type: FUNC
99  */
HksIpcSerializationTest004()100 static void HksIpcSerializationTest004()
101 {
102     HKS_LOG_I("enter HksIpcSerializationTest004");
103     struct HksParamSet *paramSet = nullptr;
104     int32_t ret = HksInitParamSet(&paramSet);
105     struct HksParam param = { .tag = HKS_TAG_KEY_AUTH_RESULT, .int32Param = 0 };
106     int32_t outParamInt = 1;
107     struct HksParamOut outParam = { .tag = HKS_TAG_KEY_AUTH_RESULT, .int32Param = &outParamInt };
108     ret = HksAddParams(paramSet, &param, 1);
109     ret = HksBuildParamSet(&paramSet);
110     ret = HksParamSetToParams(paramSet, &outParam, 1);
111     HksFreeParamSet(&paramSet);
112 }
113 
114 /**
115  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest005
116  * @tc.desc: tdd HksParamSetToParams, expect HKS_SUCCESS
117  * @tc.type: FUNC
118  */
HksIpcSerializationTest005()119 static void HksIpcSerializationTest005()
120 {
121     HKS_LOG_I("enter HksIpcSerializationTest005");
122     struct HksParamSet *paramSet = nullptr;
123     int32_t ret = HksInitParamSet(&paramSet);
124     struct HksParam param = { .tag = HKS_TAG_ACCESS_TIME, .uint32Param = 0 };
125     uint32_t outParamUint = 1;
126     struct HksParamOut outParam = { .tag = HKS_TAG_ACCESS_TIME, .uint32Param = &outParamUint };
127     ret = HksAddParams(paramSet, &param, 1);
128     ret = HksBuildParamSet(&paramSet);
129     ret = HksParamSetToParams(paramSet, &outParam, 1);
130     HksFreeParamSet(&paramSet);
131 }
132 
133 /**
134  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest006
135  * @tc.desc: tdd HksParamSetToParams, expect HKS_SUCCESS
136  * @tc.type: FUNC
137  */
HksIpcSerializationTest006()138 static void HksIpcSerializationTest006()
139 {
140     HKS_LOG_I("enter HksIpcSerializationTest006");
141     struct HksParamSet *paramSet = nullptr;
142     int32_t ret = HksInitParamSet(&paramSet);
143     struct HksParam param = { .tag = HKS_TAG_IF_NEED_APPEND_AUTH_INFO, .boolParam = true };
144     bool outParamBool = false;
145     struct HksParamOut outParam = { .tag = HKS_TAG_IF_NEED_APPEND_AUTH_INFO, .boolParam = &outParamBool };
146     ret = HksAddParams(paramSet, &param, 1);
147     ret = HksBuildParamSet(&paramSet);
148     ret = HksParamSetToParams(paramSet, &outParam, 1);
149     HksFreeParamSet(&paramSet);
150 }
151 
152 /**
153  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest007
154  * @tc.desc: tdd HksParamSetToParams, expect HKS_SUCCESS
155  * @tc.type: FUNC
156  */
HksIpcSerializationTest007()157 static void HksIpcSerializationTest007()
158 {
159     HKS_LOG_I("enter HksIpcSerializationTest007");
160     struct HksParamSet *paramSet = nullptr;
161     int32_t ret = HksInitParamSet(&paramSet);
162     struct HksParam param = { .tag = HKS_TAG_KEY_ACCESS_TIME, .uint64Param = 0 };
163     uint64_t outParamUint = 1;
164     struct HksParamOut outParam = { .tag = HKS_TAG_KEY_ACCESS_TIME, .uint64Param = &outParamUint };
165     ret = HksAddParams(paramSet, &param, 1);
166     ret = HksBuildParamSet(&paramSet);
167     ret = HksParamSetToParams(paramSet, &outParam, 1);
168     HksFreeParamSet(&paramSet);
169 }
170 
171 /**
172  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest008
173  * @tc.desc: tdd HksParamSetToParams, expect HKS_ERROR_INVALID_ARGUMENT
174  * @tc.type: FUNC
175  */
HksIpcSerializationTest008()176 static void HksIpcSerializationTest008()
177 {
178     HKS_LOG_I("enter HksIpcSerializationTest008");
179     struct HksParamSet *paramSet = nullptr;
180     int32_t ret = HksInitParamSet(&paramSet);
181     struct HksParam param = { .tag = HKS_TAG_KEY_ACCESS_TIME ^ HKS_TAG_TYPE_ULONG, .uint64Param = 0 };
182     uint64_t outParamUint = 1;
183     struct HksParamOut outParam = { .tag = HKS_TAG_KEY_ACCESS_TIME ^ HKS_TAG_TYPE_ULONG, .uint64Param = &outParamUint };
184     ret = HksAddParams(paramSet, &param, 1);
185     ret = HksBuildParamSet(&paramSet);
186     ret = HksParamSetToParams(paramSet, &outParam, 1);
187     HksFreeParamSet(&paramSet);
188 }
189 
190 /**
191  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest009
192  * @tc.desc: tdd HksParamSetToParams, expect HKS_ERROR_PARAM_NOT_EXIST
193  * @tc.type: FUNC
194  */
HksIpcSerializationTest009()195 static void HksIpcSerializationTest009()
196 {
197     HKS_LOG_I("enter HksIpcSerializationTest009");
198     struct HksParamSet *paramSet = nullptr;
199     int32_t ret = HksInitParamSet(&paramSet);
200     const char *alias = "alias";
201     struct HksBlob aliasBlob = { .size = strlen(alias), .data = (uint8_t *)alias };
202     struct HksParamOut aliasOutParam = { .tag = HKS_TAG_ATTESTATION_ID_ALIAS, .blob = &aliasBlob };
203     ret = HksBuildParamSet(&paramSet);
204     ret = HksParamSetToParams(paramSet, &aliasOutParam, 1);
205     HksFreeParamSet(&paramSet);
206 }
207 
208 /**
209  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest010
210  * @tc.desc: tdd GetBlobFromBuffer, expect HKS_ERROR_BUFFER_TOO_SMALL
211  * @tc.type: FUNC
212  */
HksIpcSerializationTest010()213 static void HksIpcSerializationTest010()
214 {
215     HKS_LOG_I("enter HksIpcSerializationTest010");
216     const uint32_t blobSize = 15;
217     const uint32_t srcBlobSize = 15;
218     uint32_t index = 16;
219     uint8_t blobData[blobSize] = { 0 };
220     uint8_t srcBlobData[srcBlobSize] = { 0 };
221     struct HksBlob blob = { .size = blobSize, .data = blobData };
222     struct HksBlob srcBlob = { .size = srcBlobSize, .data = srcBlobData };
223 
224     GetBlobFromBuffer(&blob, &srcBlob, &index);
225 }
226 
227 /**
228  * @tc.name: HksIpcSerializationTest.HksIpcSerializationTest011
229  * @tc.desc: tdd GetBlobFromBuffer, expect HKS_ERROR_BUFFER_TOO_SMALL
230  * @tc.type: FUNC
231  */
HksIpcSerializationTest011()232 static void HksIpcSerializationTest011()
233 {
234     HKS_LOG_I("enter HksIpcSerializationTest011");
235     const uint32_t blobSize = 15;
236     const uint32_t srcBlobSize = 15;
237     uint32_t index = 15;
238     uint8_t blobData[blobSize] = { 0 };
239     uint8_t srcBlobData[srcBlobSize] = { 0 };
240     struct HksBlob blob = { .size = blobSize, .data = blobData };
241     struct HksBlob srcBlob = { .size = srcBlobSize, .data = srcBlobData };
242 
243     GetBlobFromBuffer(&blob, &srcBlob, &index);
244 }
245 }
246 }
247 }
248 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)249 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
250 {
251     (void)data;
252     (void)size;
253     OHOS::Security::Hks::HksIpcSerializationTest001();
254     OHOS::Security::Hks::HksIpcSerializationTest002();
255     OHOS::Security::Hks::HksIpcSerializationTest003();
256     OHOS::Security::Hks::HksIpcSerializationTest004();
257     OHOS::Security::Hks::HksIpcSerializationTest005();
258     OHOS::Security::Hks::HksIpcSerializationTest006();
259     OHOS::Security::Hks::HksIpcSerializationTest007();
260     OHOS::Security::Hks::HksIpcSerializationTest008();
261     OHOS::Security::Hks::HksIpcSerializationTest009();
262     OHOS::Security::Hks::HksIpcSerializationTest010();
263     OHOS::Security::Hks::HksIpcSerializationTest011();
264     return 0;
265 }
266