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 "time_service_ipc_interface_code.h"
24 #include "timer_proxy.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) {};
35 int32_t uid = static_cast<int32_t>(*data);
36
37 TimerProxy::GetInstance().ProxyTimer(uid, true, true, now, callback);
38 TimerProxy::GetInstance().ProxyTimer(uid, true, false, now, callback);
39 TimerProxy::GetInstance().ProxyTimer(uid, false, true, now, callback);
40 TimerProxy::GetInstance().ProxyTimer(uid, false, false, now, callback);
41
42 TimerProxy::GetInstance().PidProxyTimer(uid, true, true, now, callback);
43 TimerProxy::GetInstance().PidProxyTimer(uid, true, false, now, callback);
44 TimerProxy::GetInstance().PidProxyTimer(uid, false, true, now, callback);
45 TimerProxy::GetInstance().PidProxyTimer(uid, false, false, now, callback);
46 return true;
47 }
48
FuzzTimerAdjustTimer(const uint8_t *data, size_t size)49 bool FuzzTimerAdjustTimer(const uint8_t *data, size_t size)
50 {
51 auto interval = static_cast<uint32_t>(*data);
52 auto now = std::chrono::steady_clock::now();
53 auto callback = [] (AdjustTimerCallback adjustTimer) {};
54 TimerProxy::GetInstance().AdjustTimer(true, interval, now, callback);
55 TimerProxy::GetInstance().AdjustTimer(false, interval, now, callback);
56 return true;
57 }
58
FuzzTimerSetTimerExemption(const uint8_t *data, size_t size)59 bool FuzzTimerSetTimerExemption(const uint8_t *data, size_t size)
60 {
61 std::string name(reinterpret_cast<const char *>(data), size);
62 std::unordered_set<std::string> nameArr{name};
63 TimerProxy::GetInstance().SetTimerExemption(nameArr, false);
64 TimerProxy::GetInstance().SetTimerExemption(nameArr, true);
65 return true;
66 }
67
FuzzTimerResetProxy(const uint8_t *data, size_t size)68 bool FuzzTimerResetProxy(const uint8_t *data, size_t size)
69 {
70 auto now = std::chrono::steady_clock::now();
71 auto callback = [] (std::shared_ptr<TimerInfo> &alarm) {};
72 TimerProxy::GetInstance().ResetAllProxy(now, callback);
73 return true;
74 }
75
FuzzTimerEraseTimer(const uint8_t *data, size_t size)76 bool FuzzTimerEraseTimer(const uint8_t *data, size_t size)
77 {
78 auto id = static_cast<uint64_t>(*data);
79 auto uid = static_cast<uint32_t>(*data);
80 auto pid = static_cast<int>(*data);
81 TimerProxy::GetInstance().EraseTimerFromProxyUidMap(id, uid);
82 TimerProxy::GetInstance().EraseTimerFromProxyPidMap(id, pid);
83 return true;
84 }
85
FuzzTimerRemoveTimerMap(const uint8_t *data, size_t size)86 bool FuzzTimerRemoveTimerMap(const uint8_t *data, size_t size)
87 {
88 auto id = static_cast<int64_t>(*data);
89 TimerProxy::GetInstance().RemoveUidTimerMap(id);
90 TimerProxy::GetInstance().RemovePidTimerMap(id);
91 return true;
92 }
93
FuzzTimerIsProxy(const uint8_t *data, size_t size)94 bool FuzzTimerIsProxy(const uint8_t *data, size_t size)
95 {
96 auto id = static_cast<int32_t>(*data);
97 TimerProxy::GetInstance().IsUidProxy(id);
98 TimerProxy::GetInstance().IsPidProxy(id);
99 return true;
100 }
101
102 } // namespace OHOS
103
104 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)105 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
106 {
107 if (size < OHOS::THRESHOLD) {
108 return 0;
109 }
110
111 /* Run your code on data */
112 OHOS::FuzzTimerProxyTimer(data, size);
113 OHOS::FuzzTimerAdjustTimer(data, size);
114 OHOS::FuzzTimerSetTimerExemption(data, size);
115 OHOS::FuzzTimerResetProxy(data, size);
116 OHOS::FuzzTimerEraseTimer(data, size);
117 OHOS::FuzzTimerRemoveTimerMap(data, size);
118 OHOS::FuzzTimerIsProxy(data, size);
119 return 0;
120 }