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 "pin_auth_executor_callback_hdi_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20
21 #include "parcel.h"
22
23 #include "iam_common_defines.h"
24 #include "iam_fuzz_test.h"
25 #include "iam_logger.h"
26 #include "iam_ptr.h"
27
28 #include "mock_iall_in_one_executor_fuzzer.h"
29 #include "mock_icollector_executor_fuzzer.h"
30 #include "mock_iexecutor_callback_fuzzer.h"
31
32 #include "pin_auth_executor_callback_hdi.h"
33 #include "pin_auth_hdi.h"
34
35 #define LOG_TAG "PIN_AUTH_SA"
36
37 #undef private
38
39 using namespace std;
40 using namespace OHOS::UserIam::Common;
41
42 namespace OHOS {
43 namespace UserIam {
44 namespace PinAuth {
45 namespace {
46
47 const uint64_t SCHEDULE_ID = 123;
48 const uint32_t TOKEN_ID = 2;
49 auto allInOneExecutorProxy_ = sptr<IAllInOneExecutor>(new (std::nothrow) MockIAllInOneExecutorFuzzer);
50 auto allInOneHdi_ = Common::MakeShared<PinAuthAllInOneHdi>(allInOneExecutorProxy_);
51 auto collectorExecutorProxy_ = sptr<ICollector>(new (std::nothrow) MockICollectorExecutorFuzzer);
52 auto collectorHdi_ = Common::MakeShared<PinAuthCollectorHdi>(collectorExecutorProxy_);
53 auto frameWorkCallback_ = Common::MakeShared<MockIExecutorCallbackFuzzer>();
54 std::shared_ptr<PinAuthExecutorCallbackHdi> pinAuthExecutorCallbackHdi_(nullptr);
55
InitPinAuthExecutorCallbackHdi(Parcel & parcel)56 void InitPinAuthExecutorCallbackHdi(Parcel &parcel)
57 {
58 const UserAuth::ExecutorParam executorParam = {
59 .tokenId = TOKEN_ID,
60 .authIntent = 0,
61 .scheduleId = SCHEDULE_ID,
62 };
63 GetDataMode mode = static_cast<GetDataMode>(parcel.ReadInt32());
64 if (parcel.ReadBool()) {
65 pinAuthExecutorCallbackHdi_ = Common::MakeShared<PinAuthExecutorCallbackHdi>(
66 frameWorkCallback_, allInOneHdi_, executorParam, mode);
67 } else {
68 pinAuthExecutorCallbackHdi_ = Common::MakeShared<PinAuthExecutorCallbackHdi>(
69 frameWorkCallback_, collectorHdi_, executorParam, mode);
70 }
71 }
72
FuzzDoVibrator(Parcel & parcel)73 void FuzzDoVibrator(Parcel &parcel)
74 {
75 IAM_LOGI("begin");
76 GetDataMode mode = static_cast<GetDataMode>(parcel.ReadInt32());
77 int32_t code = UserAuth::FAIL;
78 std::vector<uint8_t> extraInfo;
79 FillFuzzUint8Vector(parcel, extraInfo);
80 const UserAuth::ExecutorParam executorParam = {
81 .tokenId = TOKEN_ID,
82 .authIntent = 0,
83 .scheduleId = SCHEDULE_ID,
84 };
85 pinAuthExecutorCallbackHdi_ = Common::MakeShared<PinAuthExecutorCallbackHdi>(
86 frameWorkCallback_, allInOneHdi_, executorParam, mode);
87 UserAuth::ExecutorInfo info;
88 if (pinAuthExecutorCallbackHdi_ != nullptr) {
89 pinAuthExecutorCallbackHdi_->OnResult(code, extraInfo);
90 }
91 IAM_LOGI("end");
92 }
93
FuzzOnResult(Parcel & parcel)94 void FuzzOnResult(Parcel &parcel)
95 {
96 IAM_LOGI("begin");
97 int32_t code = UserAuth::FAIL;
98 std::vector<uint8_t> extraInfo;
99 FillFuzzUint8Vector(parcel, extraInfo);
100 if (pinAuthExecutorCallbackHdi_ != nullptr) {
101 pinAuthExecutorCallbackHdi_->OnResult(code, extraInfo);
102 }
103 IAM_LOGI("end");
104 }
105
FuzzOnGetData(Parcel & parcel)106 void FuzzOnGetData(Parcel &parcel)
107 {
108 IAM_LOGI("begin");
109 std::vector<uint8_t> algoParameter;
110 uint64_t authSubType = static_cast<uint64_t>(parcel.ReadUint32());
111 uint32_t algoVersion = parcel.ReadUint32();
112 std::vector<uint8_t> challenge;
113 std::string pinComplexityReg;
114 FillFuzzUint8Vector(parcel, algoParameter);
115 FillFuzzUint8Vector(parcel, challenge);
116 if (pinAuthExecutorCallbackHdi_ != nullptr) {
117 pinAuthExecutorCallbackHdi_->OnGetData(algoParameter, authSubType, algoVersion, challenge,
118 pinComplexityReg);
119 }
120 IAM_LOGI("end");
121 }
122
FuzzOnTip(Parcel & parcel)123 void FuzzOnTip(Parcel &parcel)
124 {
125 IAM_LOGI("begin");
126 uint32_t tip = parcel.ReadUint32();
127 std::vector<uint8_t> extraInfo;
128 FillFuzzUint8Vector(parcel, extraInfo);
129 if (pinAuthExecutorCallbackHdi_ != nullptr) {
130 pinAuthExecutorCallbackHdi_->OnTip(tip, extraInfo);
131 }
132 IAM_LOGI("end");
133 }
134
FuzzOnMessage(Parcel & parcel)135 void FuzzOnMessage(Parcel &parcel)
136 {
137 IAM_LOGI("begin");
138 int32_t destRole = parcel.ReadInt32();
139 std::vector<uint8_t> msg;
140 FillFuzzUint8Vector(parcel, msg);
141 if (pinAuthExecutorCallbackHdi_ != nullptr) {
142 pinAuthExecutorCallbackHdi_->OnMessage(destRole, msg);
143 }
144 IAM_LOGI("end");
145 }
146
147 using FuzzFunc = decltype(FuzzOnResult);
148 FuzzFunc *g_fuzzFuncs[] = {FuzzDoVibrator, FuzzOnResult, FuzzOnGetData, FuzzOnTip, FuzzOnMessage};
149
PinAuthExecutorCallbackHdiFuzzTest(const uint8_t * data,size_t size)150 void PinAuthExecutorCallbackHdiFuzzTest(const uint8_t *data, size_t size)
151 {
152 Parcel parcel;
153 parcel.WriteBuffer(data, size);
154 parcel.RewindRead(0);
155 InitPinAuthExecutorCallbackHdi(parcel);
156 uint32_t index = parcel.ReadUint32() % (sizeof(g_fuzzFuncs) / sizeof(FuzzFunc *));
157 auto fuzzFunc = g_fuzzFuncs[index];
158 fuzzFunc(parcel);
159 return;
160 }
161 } // namespace
162 } // namespace PinAuth
163 } // namespace UserIam
164 } // namespace OHOS
165
166 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)167 extern "C" int32_t LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
168 {
169 OHOS::UserIam::PinAuth::PinAuthExecutorCallbackHdiFuzzTest(data, size);
170 return 0;
171 }
172