Debian Codegraph @

testing/fuzzing/e2e_fuzz_test.cc

raw
1 #include <fcntl.h>
2 #include <sys/stat.h>
3 #include <sys/types.h>
4 #include <unistd.h>
5
6 #include <cassert>
7 #include <cstdio>
8 #include <functional>
9 #include <vector>
10
11 #include "../../toxcore/crypto_core.h"
12 #include "../../toxcore/tox.h"
13 #include "../../toxcore/tox_dispatch.h"
14 #include "../../toxcore/tox_events.h"
15 #include "../support/public/fuzz_data.hh"
16 #include "../support/public/fuzz_helpers.hh"
17 #include "../support/public/simulated_environment.hh"
18
19 namespace {
20
21 using tox::test::configure_fuzz_memory_source;
22 using tox::test::configure_fuzz_packet_source;
23 using tox::test::configure_fuzz_random_source;
24 using tox::test::FakeClock;
25 using tox::test::Fuzz_Data;
26 using tox::test::SimulatedEnvironment;
27
28 template <typename T>
29 using Ptr = std::unique_ptr<T, void (*)(T *)>;
30
31 void setup_callbacks(Tox_Dispatch *dispatch)
32 {
33 tox_events_callback_conference_connected(
34 dispatch, [](const Tox_Event_Conference_Connected *event, void *user_data) {
35 assert(event == nullptr);
36 });
37 tox_events_callback_conference_connected(
38 dispatch, [](const Tox_Event_Conference_Connected *event, void *user_data) {
39 assert(event != nullptr);
40 });
41 tox_events_callback_conference_invite(
42 dispatch, [](const Tox_Event_Conference_Invite *event, void *user_data) {
43 Tox *tox = static_cast<Tox *>(user_data);
44 const uint32_t friend_number = tox_event_conference_invite_get_friend_number(event);
45 const uint8_t *cookie = tox_event_conference_invite_get_cookie(event);
46 const uint32_t cookie_length = tox_event_conference_invite_get_cookie_length(event);
47 tox_conference_join(tox, friend_number, cookie, cookie_length, nullptr);
48 });
49 tox_events_callback_conference_message(
50 dispatch, [](const Tox_Event_Conference_Message *event, void *user_data) {
51 assert(event != nullptr);
52 });
53 tox_events_callback_conference_peer_list_changed(
54 dispatch, [](const Tox_Event_Conference_Peer_List_Changed *event, void *user_data) {
55 assert(event != nullptr);
56 });
57 tox_events_callback_conference_peer_name(
58 dispatch, [](const Tox_Event_Conference_Peer_Name *event, void *user_data) {
59 assert(event != nullptr);
60 });
61 tox_events_callback_conference_title(dispatch,
62 [](const Tox_Event_Conference_Title *event, void *user_data) { assert(event != nullptr); });
63 tox_events_callback_file_chunk_request(
64 dispatch, [](const Tox_Event_File_Chunk_Request *event, void *user_data) {
65 assert(event == nullptr);
66 });
67 tox_events_callback_file_recv(dispatch, [](const Tox_Event_File_Recv *event, void *user_data) {
68 Tox *tox = static_cast<Tox *>(user_data);
69 const uint32_t friend_number = tox_event_file_recv_get_friend_number(event);
70 const uint32_t file_number = tox_event_file_recv_get_file_number(event);
71 tox_file_control(tox, friend_number, file_number, TOX_FILE_CONTROL_RESUME, nullptr);
72 });
73 tox_events_callback_file_recv_chunk(dispatch,
74 [](const Tox_Event_File_Recv_Chunk *event, void *user_data) { assert(event != nullptr); });
75 tox_events_callback_file_recv_control(
76 dispatch, [](const Tox_Event_File_Recv_Control *event, void *user_data) {
77 assert(event != nullptr);
78 });
79 tox_events_callback_friend_connection_status(
80 dispatch, [](const Tox_Event_Friend_Connection_Status *event, void *user_data) {
81 // OK: friend came online.
82 const uint32_t friend_number
83 = tox_event_friend_connection_status_get_friend_number(event);
84 assert(friend_number != UINT32_MAX);
85 });
86 tox_events_callback_friend_lossless_packet(
87 dispatch, [](const Tox_Event_Friend_Lossless_Packet *event, void *user_data) {
88 Tox *tox = static_cast<Tox *>(user_data);
89 const uint32_t friend_number
90 = tox_event_friend_lossless_packet_get_friend_number(event);
91 const uint32_t data_length = tox_event_friend_lossless_packet_get_data_length(event);
92 const uint8_t *data = tox_event_friend_lossless_packet_get_data(event);
93 tox_friend_send_lossless_packet(tox, friend_number, data, data_length, nullptr);
94 });
95 tox_events_callback_friend_lossy_packet(
96 dispatch, [](const Tox_Event_Friend_Lossy_Packet *event, void *user_data) {
97 Tox *tox = static_cast<Tox *>(user_data);
98 const uint32_t friend_number = tox_event_friend_lossy_packet_get_friend_number(event);
99 const uint32_t data_length = tox_event_friend_lossy_packet_get_data_length(event);
100 const uint8_t *data = tox_event_friend_lossy_packet_get_data(event);
101 tox_friend_send_lossy_packet(tox, friend_number, data, data_length, nullptr);
102 });
103 tox_events_callback_friend_message(
104 dispatch, [](const Tox_Event_Friend_Message *event, void *user_data) {
105 Tox *tox = static_cast<Tox *>(user_data);
106 const uint32_t friend_number = tox_event_friend_message_get_friend_number(event);
107 const Tox_Message_Type type = tox_event_friend_message_get_type(event);
108 const uint32_t message_length = tox_event_friend_message_get_message_length(event);
109 const uint8_t *message = tox_event_friend_message_get_message(event);
110 tox_friend_send_message(tox, friend_number, type, message, message_length, nullptr);
111 });
112 tox_events_callback_friend_name(
113 dispatch, [](const Tox_Event_Friend_Name *event, void *user_data) {
114 // OK: friend name received.
115 });
116 tox_events_callback_friend_read_receipt(
117 dispatch, [](const Tox_Event_Friend_Read_Receipt *event, void *user_data) {
118 // OK: message has been received.
119 });
120 tox_events_callback_friend_request(
121 dispatch, [](const Tox_Event_Friend_Request *event, void *user_data) {
122 Tox *tox = static_cast<Tox *>(user_data);
123 Tox_Err_Friend_Add err;
124 tox_friend_add_norequest(tox, tox_event_friend_request_get_public_key(event), &err);
125 });
126 tox_events_callback_friend_status(
127 dispatch, [](const Tox_Event_Friend_Status *event, void *user_data) {
128 // OK: friend status received.
129 });
130 tox_events_callback_friend_status_message(
131 dispatch, [](const Tox_Event_Friend_Status_Message *event, void *user_data) {
132 // OK: friend status message received.
133 });
134 tox_events_callback_friend_typing(
135 dispatch, [](const Tox_Event_Friend_Typing *event, void *user_data) {
136 // OK: friend may be typing.
137 });
138 tox_events_callback_self_connection_status(
139 dispatch, [](const Tox_Event_Self_Connection_Status *event, void *user_data) {
140 // OK: we got connected.
141 });
142 }
143
144 void TestEndToEnd(Fuzz_Data &input)
145 {
146 SimulatedEnvironment env;
147 env.fake_clock().advance(1000000000); // Match legacy behavior
148 auto node = env.create_node(33445);
149 configure_fuzz_memory_source(env.fake_memory(), input);
150 configure_fuzz_packet_source(*node->endpoint, input);
151 configure_fuzz_random_source(env.fake_random(), input);
152
153 // Null system replacement for event comparison
154 SimulatedEnvironment null_env;
155 auto null_node = null_env.create_node(0);
156
157 Ptr<Tox_Options> opts(tox_options_new(nullptr), tox_options_free);
158 assert(opts != nullptr);
159 tox_options_set_local_discovery_enabled(opts.get(), false);
160
161 tox_options_set_log_callback(opts.get(),
162 [](Tox *tox, Tox_Log_Level level, const char *file, uint32_t line, const char *func,
163 const char *message, void *user_data) {
164 // Log to stdout.
165 if (Fuzz_Data::FUZZ_DEBUG) {
166 // Approximate level name mapping
167 char level_char = '?';
168 switch (level) {
169 case TOX_LOG_LEVEL_TRACE:
170 level_char = 'T';
171 break;
172 case TOX_LOG_LEVEL_DEBUG:
173 level_char = 'D';
174 break;
175 case TOX_LOG_LEVEL_INFO:
176 level_char = 'I';
177 break;
178 case TOX_LOG_LEVEL_WARNING:
179 level_char = 'W';
180 break;
181 case TOX_LOG_LEVEL_ERROR:
182 level_char = 'E';
183 break;
184 }
185 std::printf("[tox1] %c %s:%u(%s): %s\n", level_char, file, line, func, message);
186 }
187 });
188
189 Tox_Options_Testing tox_options_testing;
190 tox_options_testing.operating_system = &node->system;
191
192 Tox_Err_New error_new;
193 Tox_Err_New_Testing error_new_testing;
194 Tox *tox = tox_new_testing(opts.get(), &error_new, &tox_options_testing, &error_new_testing);
195
196 if (tox == nullptr) {
197 // It might fail, because some I/O happens in tox_new, and the fuzzer
198 // might do things that make that I/O fail.
199 return;
200 }
201
202 assert(error_new == TOX_ERR_NEW_OK);
203 assert(error_new_testing == TOX_ERR_NEW_TESTING_OK);
204
205 tox_events_init(tox);
206
207 Tox_Dispatch *dispatch = tox_dispatch_new(nullptr);
208 assert(dispatch != nullptr);
209 setup_callbacks(dispatch);
210
211 // MIN_ITERATION_INTERVAL = 20
212 const uint8_t MIN_ITERATION_INTERVAL = 20;
213
214 while (!input.empty()) {
215 Tox_Err_Events_Iterate error_iterate;
216 Tox_Events *events = tox_events_iterate(tox, true, &error_iterate);
217 assert(tox_events_equal(&null_node->system, events, events));
218 tox_dispatch_invoke(dispatch, events, tox);
219 tox_events_free(events);
220
221 uint32_t rand_val = env.fake_random().uniform(256);
222 env.fake_clock().advance(std::max<uint64_t>(MIN_ITERATION_INTERVAL, rand_val));
223 }
224
225 tox_dispatch_free(dispatch);
226 tox_kill(tox);
227 }
228
229 const std::vector<uint8_t> startup_data = [] {
230 constexpr char startup_file[] = "tools/toktok-fuzzer/init/e2e_fuzz_test.dat";
231
232 struct stat statbuf;
233 const int res = stat(startup_file, &statbuf);
234 assert(res == 0);
235 const int fd = open(startup_file, O_RDONLY);
236 assert(fd > 0);
237
238 std::vector<uint8_t> data(statbuf.st_size);
239
240 const ssize_t read_count = read(fd, data.data(), data.size());
241 assert(read_count > 0 && read_count == statbuf.st_size);
242 return data;
243 }();
244
245 }
246
247 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
248 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
249 {
250 std::vector<uint8_t> full_data(startup_data.size() + size);
251 std::copy(startup_data.begin(), startup_data.end(), full_data.begin());
252 std::copy(data, data + size, full_data.begin() + startup_data.size());
253
254 Fuzz_Data input{full_data.data(), full_data.size()};
255 TestEndToEnd(input);
256 return 0; // Non-zero return values are reserved for future use.
257 }