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
35using namespace OHOS::Telephony;
36namespace OHOS {
37using namespace EventFwk;
38constexpr int32_t SLOT_NUM = 2;
39bool g_flag = false;
40
41void 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
100void 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 */
150extern "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