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 "timerproxy_fuzzer.h"
17 #include "timer_call_back.h"
18
19 #include <cstddef>
20 #include <cstdint>
21 #include <string_ex.h>
22
23 #include "time_service_fuzz_utils.h"
24 #include "timer_proxy.h"
25 #include <fuzzer/FuzzedDataProvider.h>
26
27 using namespace OHOS::MiscServices;
28
29 namespace OHOS {
30 constexpr size_t THRESHOLD = 4;
31
FuzzTimerProxyTimer(const uint8_t * data,size_t size)32 bool FuzzTimerProxyTimer(const uint8_t *data, size_t size)
33 {
34 auto now = std::chrono::steady_clock::now();
35 auto callback = [] (std::shared_ptr<TimerInfo> &alarm, bool needRetrigger) {};
36 FuzzedDataProvider fdp(data, size);
37 int uid = fdp.ConsumeIntegral<uint32_t>();
38 int pid = fdp.ConsumeIntegral<int>();
39
40 TimerProxy::GetInstance().ProxyTimer(uid, pid, true, true, now, callback);
41 TimerProxy::GetInstance().ProxyTimer(uid, pid, true, false, now, callback);
42 TimerProxy::GetInstance().ProxyTimer(uid, pid, false, true, now, callback);
43 TimerProxy::GetInstance().ProxyTimer(uid, pid, false, false, now, callback);
44 return true;
45 }
46
FuzzTimerAdjustTimer(const uint8_t * data,size_t size)47 bool FuzzTimerAdjustTimer(const uint8_t *data, size_t size)
48 {
49 auto interval = static_cast<uint32_t>(*data);
50 auto now = std::chrono::steady_clock::now();
51 auto callback = [] (AdjustTimerCallback adjustTimer) {};
52 TimerProxy::GetInstance().AdjustTimer(true, interval, now, 0, callback);
53 TimerProxy::GetInstance().AdjustTimer(false, interval, now, 0, callback);
54 return true;
55 }
56
FuzzTimerSetTimerExemption(const uint8_t * data,size_t size)57 bool FuzzTimerSetTimerExemption(const uint8_t *data, size_t size)
58 {
59 std::string name(reinterpret_cast<const char *>(data), size);
60 std::unordered_set<std::string> nameArr{name};
61 TimerProxy::GetInstance().SetTimerExemption(nameArr, false);
62 TimerProxy::GetInstance().SetTimerExemption(nameArr, true);
63 return true;
64 }
65
FuzzTimerResetProxy(const uint8_t * data,size_t size)66 bool FuzzTimerResetProxy(const uint8_t *data, size_t size)
67 {
68 uint64_t offset = static_cast<uint64_t>(*data);
69 auto now = std::chrono::steady_clock::now() + std::chrono::nanoseconds(offset);
70 auto callback = [] (std::shared_ptr<TimerInfo> &alarm, bool needRetrigger) {};
71 TimerProxy::GetInstance().ResetAllProxy(now, callback);
72 return true;
73 }
74
FuzzTimerEraseTimer(const uint8_t * data,size_t size)75 bool FuzzTimerEraseTimer(const uint8_t *data, size_t size)
76 {
77 FuzzedDataProvider fdp(data, size);
78 uint64_t id = fdp.ConsumeIntegral<uint64_t>();
79 uint32_t uid = fdp.ConsumeIntegral<uint32_t>();
80 int pid = fdp.ConsumeIntegral<int>();
81 TimerProxy::GetInstance().EraseTimerFromProxyTimerMap(id, uid, pid);
82 return true;
83 }
84
FuzzTimerRemoveTimerMap(const uint8_t * data,size_t size)85 bool FuzzTimerRemoveTimerMap(const uint8_t *data, size_t size)
86 {
87 auto id = static_cast<int64_t>(*data);
88 TimerProxy::GetInstance().RemoveUidTimerMap(id);
89 return true;
90 }
91
FuzzTimerIsProxy(const uint8_t * data,size_t size)92 bool FuzzTimerIsProxy(const uint8_t *data, size_t size)
93 {
94 FuzzedDataProvider fdp(data, size);
95 int uid = fdp.ConsumeIntegral<int>();
96 int pid = fdp.ConsumeIntegral<int>();
97 TimerProxy::GetInstance().IsProxy(uid, pid);
98 return true;
99 }
100 } // namespace OHOS
101
102 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)103 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
104 {
105 if (size < OHOS::THRESHOLD) {
106 return 0;
107 }
108
109 /* Run your code on data */
110 OHOS::FuzzTimerProxyTimer(data, size);
111 OHOS::FuzzTimerAdjustTimer(data, size);
112 OHOS::FuzzTimerSetTimerExemption(data, size);
113 OHOS::FuzzTimerResetProxy(data, size);
114 OHOS::FuzzTimerEraseTimer(data, size);
115 OHOS::FuzzTimerRemoveTimerMap(data, size);
116 OHOS::FuzzTimerIsProxy(data, size);
117 return 0;
118 }