1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
|
/* DHT.h
*
* An implementation of the DHT as seen in docs/updates/DHT.md
*
* Copyright (C) 2013 Tox project All Rights Reserved.
*
* This file is part of Tox.
*
* Tox is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tox is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tox. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef DHT_H
#define DHT_H
#include "crypto_core.h"
#include "network.h"
#include "ping_array.h"
/* Maximum number of clients stored per friend. */
#define MAX_FRIEND_CLIENTS 8
/* A list of the clients mathematically closest to ours. */
#define LCLIENT_LIST 32
/* The max number of nodes to send with send nodes. */
#define MAX_SENT_NODES 4
/* Ping timeout in seconds */
#define PING_TIMEOUT 3
/* size of DHT ping arrays. */
#define DHT_PING_ARRAY_SIZE 512
/* Ping interval in seconds for each node in our lists. */
#define PING_INTERVAL 60
/* The number of seconds for a non responsive node to become bad. */
#define PINGS_MISSED_NODE_GOES_BAD 1
#define PING_ROUNDTRIP 2
#define BAD_NODE_TIMEOUT (PING_INTERVAL + PINGS_MISSED_NODE_GOES_BAD * (PING_INTERVAL + PING_ROUNDTRIP))
/* Redefinitions of variables for safe transfer over wire. */
#define TOX_AF_INET 2
#define TOX_AF_INET6 10
#define TOX_TCP_INET 130
#define TOX_TCP_INET6 138
/* The number of "fake" friends to add (for optimization purposes and so our paths for the onion part are more random) */
#define DHT_FAKE_FRIEND_NUMBER 4
/* Functions to transfer ips safely across wire. */
void to_net_family(IP *ip);
/* return 0 on success, -1 on failure. */
int to_host_family(IP *ip);
typedef struct {
IP_Port ip_port;
uint64_t timestamp;
} IPPTs;
typedef struct {
/* Node routes request correctly (true (1) or false/didn't check (0)) */
uint8_t routes_requests_ok;
/* Time which we last checked this.*/
uint64_t routes_requests_timestamp;
uint8_t routes_requests_pingedid[crypto_box_PUBLICKEYBYTES];
/* Node sends correct send_node (true (1) or false/didn't check (0)) */
uint8_t send_nodes_ok;
/* Time which we last checked this.*/
uint64_t send_nodes_timestamp;
uint8_t send_nodes_pingedid[crypto_box_PUBLICKEYBYTES];
/* Node can be used to test other nodes (true (1) or false/didn't check (0)) */
uint8_t testing_requests;
/* Time which we last checked this.*/
uint64_t testing_timestamp;
uint8_t testing_pingedid[crypto_box_PUBLICKEYBYTES];
} Hardening;
typedef struct {
IP_Port ip_port;
uint64_t timestamp;
uint64_t last_pinged;
Hardening hardening;
/* Returned by this node. Either our friend or us. */
IP_Port ret_ip_port;
uint64_t ret_timestamp;
} IPPTsPng;
typedef struct {
uint8_t public_key[crypto_box_PUBLICKEYBYTES];
IPPTsPng assoc4;
IPPTsPng assoc6;
} Client_data;
/*----------------------------------------------------------------------------------*/
typedef struct {
/* 1 if currently hole punching, otherwise 0 */
uint8_t hole_punching;
uint32_t punching_index;
uint32_t tries;
uint32_t punching_index2;
uint64_t punching_timestamp;
uint64_t recvNATping_timestamp;
uint64_t NATping_id;
uint64_t NATping_timestamp;
} NAT;
#define DHT_FRIEND_MAX_LOCKS 32
typedef struct {
uint8_t public_key[crypto_box_PUBLICKEYBYTES];
IP_Port ip_port;
}
Node_format;
typedef struct {
uint8_t public_key[crypto_box_PUBLICKEYBYTES];
Client_data client_list[MAX_FRIEND_CLIENTS];
/* Time at which the last get_nodes request was sent. */
uint64_t lastgetnode;
/* number of times get_node packets were sent. */
uint32_t bootstrap_times;
/* Symetric NAT hole punching stuff. */
NAT nat;
uint16_t lock_count;
struct {
void (*ip_callback)(void *, int32_t, IP_Port);
void *data;
int32_t number;
} callbacks[DHT_FRIEND_MAX_LOCKS];
Node_format to_bootstrap[MAX_SENT_NODES];
unsigned int num_to_bootstrap;
} DHT_Friend;
/* Return packet size of packed node with ip_family on success.
* Return -1 on failure.
*/
int packed_node_size(uint8_t ip_family);
/* Pack number of nodes into data of maxlength length.
*
* return length of packed nodes on success.
* return -1 on failure.
*/
int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_t number);
/* Unpack data of length into nodes of size max_num_nodes.
* Put the length of the data processed in processed_data_len.
* tcp_enabled sets if TCP nodes are expected (true) or not (false).
*
* return number of unpacked nodes on success.
* return -1 on failure.
*/
int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed_data_len, const uint8_t *data,
uint16_t length, uint8_t tcp_enabled);
/*----------------------------------------------------------------------------------*/
/* struct to store some shared keys so we don't have to regenerate them for each request. */
#define MAX_KEYS_PER_SLOT 4
#define KEYS_TIMEOUT 600
typedef struct {
struct {
uint8_t public_key[crypto_box_PUBLICKEYBYTES];
uint8_t shared_key[crypto_box_BEFORENMBYTES];
uint32_t times_requested;
uint8_t stored; /* 0 if not, 1 if is */
uint64_t time_last_requested;
} keys[256 * MAX_KEYS_PER_SLOT];
} Shared_Keys;
/*----------------------------------------------------------------------------------*/
typedef int (*cryptopacket_handler_callback)(void *object, IP_Port ip_port, const uint8_t *source_pubkey,
const uint8_t *data, uint16_t len);
typedef struct {
cryptopacket_handler_callback function;
void *object;
} Cryptopacket_Handles;
typedef struct {
Networking_Core *net;
Client_data close_clientlist[LCLIENT_LIST];
uint64_t close_lastgetnodes;
uint32_t close_bootstrap_times;
/* Note: this key should not be/is not used to transmit any sensitive materials */
uint8_t secret_symmetric_key[crypto_box_KEYBYTES];
/* DHT keypair */
uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
DHT_Friend *friends_list;
uint16_t num_friends;
Node_format *loaded_nodes_list;
uint32_t loaded_num_nodes;
unsigned int loaded_nodes_index;
Shared_Keys shared_keys_recv;
Shared_Keys shared_keys_sent;
struct PING *ping;
Ping_Array dht_ping_array;
Ping_Array dht_harden_ping_array;
#ifdef ENABLE_ASSOC_DHT
struct Assoc *assoc;
#endif
uint64_t last_run;
Cryptopacket_Handles cryptopackethandlers[256];
Node_format to_bootstrap[MAX_SENT_NODES];
unsigned int num_to_bootstrap;
} DHT;
/*----------------------------------------------------------------------------------*/
/* Shared key generations are costly, it is therefor smart to store commonly used
* ones so that they can re used later without being computed again.
*
* If shared key is already in shared_keys, copy it to shared_key.
* else generate it into shared_key and copy it to shared_keys
*/
void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, const uint8_t *secret_key,
const uint8_t *public_key);
/* Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key
* for packets that we receive.
*/
void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *public_key);
/* Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key
* for packets that we send.
*/
void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *public_key);
void DHT_getnodes(DHT *dht, const IP_Port *from_ipp, const uint8_t *from_id, const uint8_t *which_id);
/* Add a new friend to the friends list.
* public_key must be crypto_box_PUBLICKEYBYTES bytes long.
*
* ip_callback is the callback of a function that will be called when the ip address
* is found along with arguments data and number.
*
* lock_count will be set to a non zero number that must be passed to DHT_delfriend()
* to properly remove the callback.
*
* return 0 if success.
* return -1 if failure (friends list is full).
*/
int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void *data, int32_t number, IP_Port),
void *data, int32_t number, uint16_t *lock_count);
/* Delete a friend from the friends list.
* public_key must be crypto_box_PUBLICKEYBYTES bytes long.
*
* return 0 if success.
* return -1 if failure (public_key not in friends list).
*/
int DHT_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count);
/* Get ip of friend.
* public_key must be crypto_box_PUBLICKEYBYTES bytes long.
* ip must be 4 bytes long.
* port must be 2 bytes long.
*
* int DHT_getfriendip(DHT *dht, uint8_t *public_key, IP_Port *ip_port);
*
* return -1, -- if public_key does NOT refer to a friend
* return 0, -- if public_key refers to a friend and we failed to find the friend (yet)
* return 1, ip if public_key refers to a friend and we found him
*/
int DHT_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port);
/* Compares pk1 and pk2 with pk.
*
* return 0 if both are same distance.
* return 1 if pk1 is closer.
* return 2 if pk2 is closer.
*/
int id_closest(const uint8_t *pk, const uint8_t *pk1, const uint8_t *pk2);
/* Get the (maximum MAX_SENT_NODES) closest nodes to public_key we know
* and put them in nodes_list (must be MAX_SENT_NODES big).
*
* sa_family = family (IPv4 or IPv6) (0 if we don't care)?
* is_LAN = return some LAN ips (true or false)
* want_good = do we want tested nodes or not? (TODO)
*
* return the number of nodes returned.
*
*/
int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *nodes_list, sa_family_t sa_family,
uint8_t is_LAN, uint8_t want_good);
/* Put up to max_num nodes in nodes from the random friends.
*
* return the number of nodes.
*/
uint16_t randfriends_nodes(DHT *dht, Node_format *nodes, uint16_t max_num);
/* Put up to max_num nodes in nodes from the closelist.
*
* return the number of nodes.
*/
uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num);
/* Run this function at least a couple times per second (It's the main loop). */
void do_DHT(DHT *dht);
/*
* Use these two functions to bootstrap the client.
*/
/* Sends a "get nodes" request to the given node with ip, port and public_key
* to setup connections
*/
void DHT_bootstrap(DHT *dht, IP_Port ip_port, const uint8_t *public_key);
/* Resolves address into an IP address. If successful, sends a "get nodes"
* request to the given node with ip, port and public_key to setup connections
*
* address can be a hostname or an IP address (IPv4 or IPv6).
* if ipv6enabled is 0 (zero), the resolving sticks STRICTLY to IPv4 addresses
* if ipv6enabled is not 0 (zero), the resolving looks for IPv6 addresses first,
* then IPv4 addresses.
*
* returns 1 if the address could be converted into an IP address
* returns 0 otherwise
*/
int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enabled,
uint16_t port, const uint8_t *public_key);
/* Start sending packets after DHT loaded_friends_list and loaded_clients_list are set.
*
* returns 0 if successful
* returns -1 otherwise
*/
int DHT_connect_after_load(DHT *dht);
/* ROUTING FUNCTIONS */
/* Send the given packet to node with public_key.
*
* return -1 if failure.
*/
int route_packet(const DHT *dht, const uint8_t *public_key, const uint8_t *packet, uint16_t length);
/* Send the following packet to everyone who tells us they are connected to friend_id.
*
* return number of nodes it sent the packet to.
*/
int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint16_t length);
/* Function to handle crypto packets.
*/
void cryptopacket_registerhandler(DHT *dht, uint8_t byte, cryptopacket_handler_callback cb, void *object);
/* SAVE/LOAD functions */
/* Get the size of the DHT (for saving). */
uint32_t DHT_size(const DHT *dht);
/* Save the DHT in data where data is an array of size DHT_size(). */
void DHT_save(DHT *dht, uint8_t *data);
/* Load the DHT from data of size size.
*
* return -1 if failure.
* return 0 if success.
*/
int DHT_load(DHT *dht, const uint8_t *data, uint32_t length);
/* Initialize DHT. */
DHT *new_DHT(Networking_Core *net);
void kill_DHT(DHT *dht);
/* return 0 if we are not connected to the DHT.
* return 1 if we are.
*/
int DHT_isconnected(const DHT *dht);
/* return 0 if we are not connected or only connected to lan peers with the DHT.
* return 1 if we are.
*/
int DHT_non_lan_connected(const DHT *dht);
int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key);
#endif
|