1 /*
2 * Copyright (c) 2022-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 "smsrecvitem_fuzzer.h"
17
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22
23 #include "addsmstoken_fuzzer.h"
24 #include "cdma_sms_message.h"
25 #include "common_event.h"
26 #include "common_event_manager.h"
27 #include "common_event_support.h"
28 #include "delivery_short_message_callback_stub.h"
29 #include "send_short_message_callback_stub.h"
30 #include "sms_broadcast_subscriber_receiver.h"
31 #include "sms_interface_manager.h"
32 #include "sms_receive_reliability_handler.h"
33 #include "string_utils.h"
34
35 using namespace OHOS::Telephony;
36 namespace OHOS {
37 using namespace EventFwk;
38 constexpr int32_t SLOT_NUM = 2;
39 bool g_flag = false;
40
DoRecvItemsTest(const uint8_t * data,size_t size,std::shared_ptr<SmsReceiveManager> smsReceiveManager)41 void DoRecvItemsTest(const uint8_t *data, size_t size, std::shared_ptr<SmsReceiveManager> smsReceiveManager)
42 {
43 const std::shared_ptr<GsmSmsMessage> smsGsmMessage = std::make_shared<GsmSmsMessage>();
44 const std::shared_ptr<CdmaSmsMessage> smsCdmaMessage = std::make_shared<CdmaSmsMessage>();
45 smsReceiveManager->gsmSmsReceiveHandler_->HandleReceivedSms(smsGsmMessage);
46 smsReceiveManager->cdmaSmsReceiveHandler_->HandleReceivedSms(smsCdmaMessage);
47 smsReceiveManager->gsmSmsReceiveHandler_->HandleSmsByType(smsGsmMessage);
48 smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(smsCdmaMessage);
49
50 std::int32_t result = static_cast<int32_t>(size);
51 smsReceiveManager->gsmSmsReceiveHandler_->ReplySmsToSmsc(result);
52 smsReceiveManager->cdmaSmsReceiveHandler_->ReplySmsToSmsc(result);
53
54 const std::shared_ptr<SmsReceiveIndexer> smsReceiveIndexer = std::make_shared<SmsReceiveIndexer>();
55 smsReceiveManager->gsmSmsReceiveHandler_->CombineMessagePart(smsReceiveIndexer);
56 smsReceiveManager->cdmaSmsReceiveHandler_->CombineMessagePart(smsReceiveIndexer);
57
58 smsReceiveManager->gsmSmsReceiveHandler_->IsRepeatedMessagePart(smsReceiveIndexer);
59 smsReceiveManager->cdmaSmsReceiveHandler_->IsRepeatedMessagePart(smsReceiveIndexer);
60
61 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
62 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(slotId);
63 if (reliabilityHandler == nullptr) {
64 return;
65 }
66 reliabilityHandler->DeleteMessageFormDb(smsReceiveIndexer->GetMsgRefId());
67
68 std::vector<SmsReceiveIndexer> dbIndexers;
69 std::string strData(reinterpret_cast<const char *>(data), size);
70 auto indexer = SmsReceiveIndexer(StringUtils::HexToByteVector(strData), size, size, size % SLOT_NUM, strData,
71 strData, size, size, size, size % SLOT_NUM, strData);
72
73 dbIndexers.push_back(indexer);
74 indexer = SmsReceiveIndexer(
75 StringUtils::HexToByteVector(strData), size, size, size % SLOT_NUM, size % SLOT_NUM, strData, strData, strData);
76 dbIndexers.push_back(indexer);
77 reliabilityHandler->CheckUnReceiveWapPush(dbIndexers);
78
79 std::shared_ptr<std::vector<std::string>> userDataRaws = std::make_shared<std::vector<std::string>>();
80 userDataRaws->push_back(strData);
81
82 int32_t pages = 0;
83 reliabilityHandler->GetWapPushUserDataSinglePage(indexer, userDataRaws);
84 reliabilityHandler->GetWapPushUserDataMultipage(pages, dbIndexers, size, userDataRaws);
85 reliabilityHandler->ReadyDecodeWapPushUserData(indexer, userDataRaws);
86 reliabilityHandler->GetSmsUserDataMultipage(pages, dbIndexers, size, userDataRaws);
87 reliabilityHandler->ReadySendSmsBroadcast(indexer, userDataRaws);
88 reliabilityHandler->DeleteMessageFormDb(size, size);
89 reliabilityHandler->RemoveBlockedSms(dbIndexers);
90
91 std::shared_ptr<SmsReceiveIndexer> indexerPtr =
92 std::make_shared<SmsReceiveIndexer>(StringUtils::HexToByteVector(strData), size, size, size % SLOT_NUM, strData,
93 strData, size, size, size, size % SLOT_NUM, strData);
94 if (indexerPtr == nullptr) {
95 return;
96 }
97 reliabilityHandler->SendBroadcast(indexerPtr, userDataRaws);
98 }
99
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)100 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
101 {
102 if (data == nullptr || size == 0) {
103 return;
104 }
105
106 if (g_flag) {
107 return;
108 }
109 g_flag = true;
110
111 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
112 auto smsInterfaceManager = std::make_shared<SmsInterfaceManager>(slotId);
113 if (smsInterfaceManager == nullptr) {
114 return;
115 }
116
117 smsInterfaceManager->InitInterfaceManager();
118 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(slotId);
119 if (smsReceiveManager == nullptr) {
120 return;
121 }
122 smsReceiveManager->Init();
123 if (smsReceiveManager->gsmSmsReceiveHandler_ == nullptr || smsReceiveManager->cdmaSmsReceiveHandler_ == nullptr) {
124 return;
125 }
126 smsReceiveManager->gsmSmsReceiveHandler_->Init();
127 smsReceiveManager->cdmaSmsReceiveHandler_->Init();
128
129 std::int32_t eventId = static_cast<int32_t>(size);
130 std::int64_t refId = static_cast<int64_t>(size);
131
132 AppExecFwk::InnerEvent::Pointer response = AppExecFwk::InnerEvent::Get(eventId, refId);
133 smsReceiveManager->gsmSmsReceiveHandler_->ProcessEvent(response);
134 smsReceiveManager->cdmaSmsReceiveHandler_->ProcessEvent(response);
135
136 MatchingSkills smsSkills;
137 std::string strData(reinterpret_cast<const char *>(data), size);
138 smsSkills.AddEvent(strData);
139 CommonEventSubscribeInfo smsSubscriberInfo(smsSkills);
140 std::string addr(reinterpret_cast<const char *>(data), size);
141 auto smsReceiver = std::make_shared<SmsBroadcastSubscriberReceiver>(smsSubscriberInfo, nullptr, size, size, addr);
142 CommonEventData comData;
143 smsReceiver->OnReceiveEvent(comData);
144
145 DoRecvItemsTest(data, size, smsReceiveManager);
146 }
147 } // namespace OHOS
148
149 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)150 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
151 {
152 /* Run your code on data */
153 OHOS::AddSmsTokenFuzzer token;
154 OHOS::DoSomethingInterestingWithMyAPI(data, size);
155 return 0;
156 }
157