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