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 "wantsixth_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <iostream>
21
22 #define private public
23 #include "want.h"
24 #undef private
25 #include "securec.h"
26
27 using namespace OHOS::AAFwk;
28
29 namespace OHOS {
30 namespace {
31 constexpr size_t U32_AT_SIZE = 4;
32 }
GetU32Data(const char * ptr)33 uint32_t GetU32Data(const char* ptr)
34 {
35 // convert fuzz input data to an integer
36 return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
37 }
38
DoGetTypeArrayParam()39 void DoGetTypeArrayParam()
40 {
41 std::shared_ptr<Want> WantIn = std::make_shared<Want>();
42 std::vector<bool> boolArrayValue = {true, false, true};
43 WantIn->SetParam(std::string("bool_arraykey"), boolArrayValue);
44
45 std::vector<byte> byteArrayValue = {'?', 'a', '\\'};
46 WantIn->SetParam(std::string("byte_arraykey"), byteArrayValue);
47
48 std::vector<zchar> charArrayValue = {U'e', U'l', U'l', U'o'};
49 WantIn->SetParam(std::string("char_arraykey"), charArrayValue);
50
51 std::vector<int> intArrayValue = {-10, 0, 10};
52 WantIn->SetParam(std::string("int_arraykey"), intArrayValue);
53
54 std::vector<double> doubleArrayValue = {-1000.1, 0.1, 1000.1};
55 WantIn->SetParam(std::string("double_arraykey"), doubleArrayValue);
56
57 std::vector<float> floatArrayValue = {-100.1, 0.1, 100.1};
58 WantIn->SetParam(std::string("float_arraykey"), floatArrayValue);
59
60 std::vector<long> longArrayValue = {-100, 0, 100};
61 WantIn->SetParam(std::string("long_arraykey"), longArrayValue);
62
63 std::vector<std::string> stringArrayValue = {"stringtest1", "string@test2", "string@!#test2"};
64 WantIn->SetParam(std::string("string_arraykey"), stringArrayValue);
65
66 std::vector<short> shortArrayValue = {-1, 0, 1};
67 WantIn->SetParam(std::string("short_arraykey"), shortArrayValue);
68
69 WantIn->GetBoolArrayParam(std::string("bool_arraykey"));
70 WantIn->GetByteArrayParam(std::string("byte_arraykey"));
71 WantIn->GetCharArrayParam(std::string("char_arraykey"));
72 WantIn->GetIntArrayParam(std::string("int_arraykey"));
73 WantIn->GetDoubleArrayParam(std::string("double_arraykey"));
74 WantIn->GetFloatArrayParam(std::string("float_arraykey"));
75 WantIn->GetLongArrayParam(std::string("long_arraykey"));
76 WantIn->GetLongArrayParam(std::string("string_arraykey"));
77 WantIn->GetShortArrayParam(std::string("short_arraykey"));
78 WantIn->GetStringArrayParam(std::string("string_arraykey"));
79 }
80
DoSomethingInterestingWithMyAPI(const char * data,size_t size)81 bool DoSomethingInterestingWithMyAPI(const char* data, size_t size)
82 {
83 std::shared_ptr<Want> want = std::make_shared<Want>();
84 std::string key(data, size);
85 std::vector<float> floatVector;
86 want->SetParam(key, floatVector);
87 want->GetFloatArrayParam(key);
88 std::vector<long> longVector;
89 want->SetParam(key, longVector);
90 want->GetLongArrayParam(key);
91 short shortValue = 0;
92 want->SetParam(key, shortValue);
93 want->GetShortParam(key, shortValue);
94 std::vector<short> shortVector;
95 want->SetParam(key, shortVector);
96 want->GetShortArrayParam(key);
97 std::vector<std::string> stringVector;
98 want->SetParam(key, stringVector);
99 Want wantSource;
100 Want wantDest(wantSource);
101 wantDest = wantSource;
102 want->GetBoolArrayParam(key);
103 DoGetTypeArrayParam();
104 return true;
105 }
106 }
107
108 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)109 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
110 {
111 /* Run your code on data */
112 if (data == nullptr) {
113 std::cout << "invalid data" << std::endl;
114 return 0;
115 }
116
117 /* Validate the length of size */
118 if (size < OHOS::U32_AT_SIZE) {
119 return 0;
120 }
121
122 char* ch = reinterpret_cast<char *>(malloc(size + 1));
123 if (ch == nullptr) {
124 std::cout << "malloc failed." << std::endl;
125 return 0;
126 }
127
128 (void)memset_s(ch, size + 1, 0x00, size + 1);
129 if (memcpy_s(ch, size, data, size) != EOK) {
130 std::cout << "copy failed." << std::endl;
131 free(ch);
132 ch = nullptr;
133 return 0;
134 }
135
136 OHOS::DoSomethingInterestingWithMyAPI(ch, size);
137 free(ch);
138 ch = nullptr;
139 return 0;
140 }
141