1 /* Copyright (c) 2001 Matej Pfajfar.
2 * Copyright (c) 2001-2004, Roger Dingledine.
3 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
4 * Copyright (c) 2007-2021, The Tor Project, Inc. */
5 /* See LICENSE for licensing information */
6
7 #define ROUTER_PRIVATE
8
9 #include "core/or/or.h"
10 #include "app/config/config.h"
11 #include "app/config/resolve_addr.h"
12 #include "app/config/statefile.h"
13 #include "app/main/main.h"
14 #include "core/mainloop/connection.h"
15 #include "core/mainloop/mainloop.h"
16 #include "core/mainloop/netstatus.h"
17 #include "core/or/policies.h"
18 #include "core/or/protover.h"
19 #include "feature/client/transports.h"
20 #include "feature/control/control_events.h"
21 #include "feature/dirauth/process_descs.h"
22 #include "feature/dircache/dirserv.h"
23 #include "feature/dirclient/dirclient.h"
24 #include "feature/dircommon/directory.h"
25 #include "feature/dirparse/authcert_parse.h"
26 #include "feature/dirparse/routerparse.h"
27 #include "feature/dirparse/signing.h"
28 #include "feature/hibernate/hibernate.h"
29 #include "feature/keymgt/loadkey.h"
30 #include "feature/nodelist/authcert.h"
31 #include "feature/nodelist/dirlist.h"
32 #include "feature/nodelist/networkstatus.h"
33 #include "feature/nodelist/nickname.h"
34 #include "feature/nodelist/nodefamily.h"
35 #include "feature/nodelist/nodelist.h"
36 #include "feature/nodelist/routerlist.h"
37 #include "feature/nodelist/torcert.h"
38 #include "feature/relay/dns.h"
39 #include "feature/relay/relay_config.h"
40 #include "feature/relay/relay_find_addr.h"
41 #include "feature/relay/relay_periodic.h"
42 #include "feature/relay/router.h"
43 #include "feature/relay/routerkeys.h"
44 #include "feature/relay/routermode.h"
45 #include "feature/relay/selftest.h"
46 #include "lib/geoip/geoip.h"
47 #include "feature/stats/geoip_stats.h"
48 #include "feature/stats/bwhist.h"
49 #include "feature/stats/rephist.h"
50 #include "lib/crypt_ops/crypto_ed25519.h"
51 #include "lib/crypt_ops/crypto_format.h"
52 #include "lib/crypt_ops/crypto_init.h"
53 #include "lib/crypt_ops/crypto_rand.h"
54 #include "lib/crypt_ops/crypto_util.h"
55 #include "lib/encoding/confline.h"
56 #include "lib/osinfo/uname.h"
57 #include "lib/tls/tortls.h"
58 #include "lib/version/torversion.h"
59
60 #include "feature/dirauth/authmode.h"
61
62 #include "app/config/or_state_st.h"
63 #include "core/or/port_cfg_st.h"
64 #include "feature/dirclient/dir_server_st.h"
65 #include "feature/dircommon/dir_connection_st.h"
66 #include "feature/nodelist/authority_cert_st.h"
67 #include "feature/nodelist/extrainfo_st.h"
68 #include "feature/nodelist/networkstatus_st.h"
69 #include "feature/nodelist/node_st.h"
70 #include "feature/nodelist/routerinfo_st.h"
71 #include "feature/nodelist/routerstatus_st.h"
72
73 /**
74 * \file router.c
75 * \brief Miscellaneous relay functionality, including RSA key maintenance,
76 * generating and uploading server descriptors, picking an address to
77 * advertise, and so on.
78 *
79 * This module handles the job of deciding whether we are a Tor relay, and if
80 * so what kind. (Mostly through functions like server_mode() that inspect an
81 * or_options_t, but in some cases based on our own capabilities, such as when
82 * we are deciding whether to be a directory cache in
83 * router_has_bandwidth_to_be_dirserver().)
84 *
85 * Also in this module are the functions to generate our own routerinfo_t and
86 * extrainfo_t, and to encode those to signed strings for upload to the
87 * directory authorities.
88 *
89 * This module also handles key maintenance for RSA and Curve25519-ntor keys,
90 * and for our TLS context. (These functions should eventually move to
91 * routerkeys.c along with the code that handles Ed25519 keys now.)
92 **/
93
94 /************************************************************/
95
96 /*****
97 * Key management: ORs only.
98 *****/
99
100 /** Private keys for this OR. There is also an SSL key managed by tortls.c.
101 */
102 static tor_mutex_t *key_lock=NULL;
103 static time_t onionkey_set_at=0; /**< When was onionkey last changed? */
104 /** Current private onionskin decryption key: used to decode CREATE cells. */
105 static crypto_pk_t *onionkey=NULL;
106 /** Previous private onionskin decryption key: used to decode CREATE cells
107 * generated by clients that have an older version of our descriptor. */
108 static crypto_pk_t *lastonionkey=NULL;
109 /** Current private ntor secret key: used to perform the ntor handshake. */
110 static curve25519_keypair_t curve25519_onion_key;
111 /** Previous private ntor secret key: used to perform the ntor handshake
112 * with clients that have an older version of our descriptor. */
113 static curve25519_keypair_t last_curve25519_onion_key;
114 /** Private server "identity key": used to sign directory info and TLS
115 * certificates. Never changes. */
116 static crypto_pk_t *server_identitykey=NULL;
117 /** Digest of server_identitykey. */
118 static char server_identitykey_digest[DIGEST_LEN];
119 /** Private client "identity key": used to sign bridges' and clients'
120 * outbound TLS certificates. Regenerated on startup and on IP address
121 * change. */
122 static crypto_pk_t *client_identitykey=NULL;
123 /** Signing key used for v3 directory material; only set for authorities. */
124 static crypto_pk_t *authority_signing_key = NULL;
125 /** Key certificate to authenticate v3 directory material; only set for
126 * authorities. */
127 static authority_cert_t *authority_key_certificate = NULL;
128
129 /** For emergency V3 authority key migration: An extra signing key that we use
130 * with our old (obsolete) identity key for a while. */
131 static crypto_pk_t *legacy_signing_key = NULL;
132 /** For emergency V3 authority key migration: An extra certificate to
133 * authenticate legacy_signing_key with our obsolete identity key.*/
134 static authority_cert_t *legacy_key_certificate = NULL;
135
136 /* (Note that v3 authorities also have a separate "authority identity key",
137 * but this key is never actually loaded by the Tor process. Instead, it's
138 * used by tor-gencert to sign new signing keys and make new key
139 * certificates. */
140
141 /** Indicate if the IPv6 address should be omitted from the descriptor when
142 * publishing it. This can happen if the IPv4 is reachable but the
143 * auto-discovered IPv6 is not. We still publish the descriptor.
144 *
145 * Only relays should look at this and only for their descriptor.
146 *
147 * XXX: The real harder fix is to never put in the routerinfo_t a non
148 * reachable address and instead use the last resolved address cache to do
149 * reachability test or anything that has to do with what address tor thinks
150 * it has. */
151 static bool omit_ipv6_on_publish = false;
152
153 /** Return a readonly string with human readable description
154 * of <b>err</b>.
155 */
156 const char *
routerinfo_err_to_string(int err)157 routerinfo_err_to_string(int err)
158 {
159 switch (err) {
160 case TOR_ROUTERINFO_ERROR_NO_EXT_ADDR:
161 return "No known exit address yet";
162 case TOR_ROUTERINFO_ERROR_CANNOT_PARSE:
163 return "Cannot parse descriptor";
164 case TOR_ROUTERINFO_ERROR_NOT_A_SERVER:
165 return "Not running in server mode";
166 case TOR_ROUTERINFO_ERROR_DIGEST_FAILED:
167 return "Key digest failed";
168 case TOR_ROUTERINFO_ERROR_CANNOT_GENERATE:
169 return "Cannot generate descriptor";
170 case TOR_ROUTERINFO_ERROR_DESC_REBUILDING:
171 return "Descriptor still rebuilding - not ready yet";
172 case TOR_ROUTERINFO_ERROR_INTERNAL_BUG:
173 return "Internal bug, see logs for details";
174 }
175
176 log_warn(LD_BUG, "unknown routerinfo error %d - shouldn't happen", err);
177 tor_assert_unreached();
178
179 return "Unknown error";
180 }
181
182 /** Return true if we expect given error to be transient.
183 * Return false otherwise.
184 */
185 int
routerinfo_err_is_transient(int err)186 routerinfo_err_is_transient(int err)
187 {
188 /**
189 * For simplicity, we consider all errors other than
190 * "not a server" transient - see discussion on
191 * https://bugs.torproject.org/tpo/core/tor/27034.
192 */
193 return err != TOR_ROUTERINFO_ERROR_NOT_A_SERVER;
194 }
195
196 /** Replace the current onion key with <b>k</b>. Does not affect
197 * lastonionkey; to update lastonionkey correctly, call rotate_onion_key().
198 */
199 static void
set_onion_key(crypto_pk_t * k)200 set_onion_key(crypto_pk_t *k)
201 {
202 if (onionkey && crypto_pk_eq_keys(onionkey, k)) {
203 /* k is already our onion key; free it and return */
204 crypto_pk_free(k);
205 return;
206 }
207 tor_mutex_acquire(key_lock);
208 crypto_pk_free(onionkey);
209 onionkey = k;
210 tor_mutex_release(key_lock);
211 mark_my_descriptor_dirty("set onion key");
212 }
213
214 /** Return the current onion key. Requires that the onion key has been
215 * loaded or generated. */
216 MOCK_IMPL(crypto_pk_t *,
217 get_onion_key,(void))
218 {
219 tor_assert(onionkey);
220 return onionkey;
221 }
222
223 /** Store a full copy of the current onion key into *<b>key</b>, and a full
224 * copy of the most recent onion key into *<b>last</b>. Store NULL into
225 * a pointer if the corresponding key does not exist.
226 */
227 void
dup_onion_keys(crypto_pk_t ** key,crypto_pk_t ** last)228 dup_onion_keys(crypto_pk_t **key, crypto_pk_t **last)
229 {
230 tor_assert(key);
231 tor_assert(last);
232 tor_mutex_acquire(key_lock);
233 if (onionkey)
234 *key = crypto_pk_copy_full(onionkey);
235 else
236 *key = NULL;
237 if (lastonionkey)
238 *last = crypto_pk_copy_full(lastonionkey);
239 else
240 *last = NULL;
241 tor_mutex_release(key_lock);
242 }
243
244 /** Expire our old set of onion keys. This is done by setting
245 * last_curve25519_onion_key and lastonionkey to all zero's and NULL
246 * respectively.
247 *
248 * This function does not perform any grace period checks for the old onion
249 * keys.
250 */
251 void
expire_old_onion_keys(void)252 expire_old_onion_keys(void)
253 {
254 char *fname = NULL;
255
256 tor_mutex_acquire(key_lock);
257
258 /* Free lastonionkey and set it to NULL. */
259 if (lastonionkey) {
260 crypto_pk_free(lastonionkey);
261 lastonionkey = NULL;
262 }
263
264 /* We zero out the keypair. See the fast_mem_is_zero() check made in
265 * construct_ntor_key_map() below. */
266 memset(&last_curve25519_onion_key, 0, sizeof(last_curve25519_onion_key));
267
268 tor_mutex_release(key_lock);
269
270 fname = get_keydir_fname("secret_onion_key.old");
271 if (file_status(fname) == FN_FILE) {
272 if (tor_unlink(fname) != 0) {
273 log_warn(LD_FS, "Couldn't unlink old onion key file %s: %s",
274 fname, strerror(errno));
275 }
276 }
277 tor_free(fname);
278
279 fname = get_keydir_fname("secret_onion_key_ntor.old");
280 if (file_status(fname) == FN_FILE) {
281 if (tor_unlink(fname) != 0) {
282 log_warn(LD_FS, "Couldn't unlink old ntor onion key file %s: %s",
283 fname, strerror(errno));
284 }
285 }
286 tor_free(fname);
287 }
288
289 /** Return the current secret onion key for the ntor handshake. Must only
290 * be called from the main thread. */
291 MOCK_IMPL(STATIC const struct curve25519_keypair_t *,
292 get_current_curve25519_keypair,(void))
293 {
294 return &curve25519_onion_key;
295 }
296
297 /** Return a map from KEYID (the key itself) to keypairs for use in the ntor
298 * handshake. Must only be called from the main thread. */
299 di_digest256_map_t *
construct_ntor_key_map(void)300 construct_ntor_key_map(void)
301 {
302 di_digest256_map_t *m = NULL;
303
304 const uint8_t *cur_pk = curve25519_onion_key.pubkey.public_key;
305 const uint8_t *last_pk = last_curve25519_onion_key.pubkey.public_key;
306
307 if (!fast_mem_is_zero((const char *)cur_pk, CURVE25519_PUBKEY_LEN)) {
308 dimap_add_entry(&m, cur_pk,
309 tor_memdup(&curve25519_onion_key,
310 sizeof(curve25519_keypair_t)));
311 }
312 if (!fast_mem_is_zero((const char*)last_pk, CURVE25519_PUBKEY_LEN) &&
313 tor_memneq(cur_pk, last_pk, CURVE25519_PUBKEY_LEN)) {
314 dimap_add_entry(&m, last_pk,
315 tor_memdup(&last_curve25519_onion_key,
316 sizeof(curve25519_keypair_t)));
317 }
318
319 return m;
320 }
321 /** Helper used to deallocate a di_digest256_map_t returned by
322 * construct_ntor_key_map. */
323 static void
ntor_key_map_free_helper(void * arg)324 ntor_key_map_free_helper(void *arg)
325 {
326 curve25519_keypair_t *k = arg;
327 memwipe(k, 0, sizeof(*k));
328 tor_free(k);
329 }
330 /** Release all storage from a keymap returned by construct_ntor_key_map. */
331 void
ntor_key_map_free_(di_digest256_map_t * map)332 ntor_key_map_free_(di_digest256_map_t *map)
333 {
334 if (!map)
335 return;
336 dimap_free(map, ntor_key_map_free_helper);
337 }
338
339 /** Return the time when the onion key was last set. This is either the time
340 * when the process launched, or the time of the most recent key rotation since
341 * the process launched.
342 */
343 time_t
get_onion_key_set_at(void)344 get_onion_key_set_at(void)
345 {
346 return onionkey_set_at;
347 }
348
349 /** Set the current server identity key to <b>k</b>.
350 */
351 void
set_server_identity_key(crypto_pk_t * k)352 set_server_identity_key(crypto_pk_t *k)
353 {
354 crypto_pk_free(server_identitykey);
355 server_identitykey = k;
356 if (crypto_pk_get_digest(server_identitykey,
357 server_identitykey_digest) < 0) {
358 log_err(LD_BUG, "Couldn't compute our own identity key digest.");
359 tor_assert(0);
360 }
361 }
362
363 #ifdef TOR_UNIT_TESTS
364 /** Testing only -- set the server's RSA identity digest to
365 * be <b>digest</b> */
366 void
set_server_identity_key_digest_testing(const uint8_t * digest)367 set_server_identity_key_digest_testing(const uint8_t *digest)
368 {
369 memcpy(server_identitykey_digest, digest, DIGEST_LEN);
370 }
371 #endif /* defined(TOR_UNIT_TESTS) */
372
373 /** Make sure that we have set up our identity keys to match or not match as
374 * appropriate, and die with an assertion if we have not. */
375 static void
assert_identity_keys_ok(void)376 assert_identity_keys_ok(void)
377 {
378 if (1)
379 return;
380 tor_assert(client_identitykey);
381 if (public_server_mode(get_options())) {
382 /* assert that we have set the client and server keys to be equal */
383 tor_assert(server_identitykey);
384 tor_assert(crypto_pk_eq_keys(client_identitykey, server_identitykey));
385 } else {
386 /* assert that we have set the client and server keys to be unequal */
387 if (server_identitykey)
388 tor_assert(!crypto_pk_eq_keys(client_identitykey, server_identitykey));
389 }
390 }
391
392 #ifdef HAVE_MODULE_RELAY
393
394 /** Returns the current server identity key; requires that the key has
395 * been set, and that we are running as a Tor server.
396 */
397 MOCK_IMPL(crypto_pk_t *,
398 get_server_identity_key,(void))
399 {
400 tor_assert(server_identitykey);
401 tor_assert(server_mode(get_options()) ||
402 get_options()->command == CMD_KEY_EXPIRATION);
403 assert_identity_keys_ok();
404 return server_identitykey;
405 }
406
407 #endif /* defined(HAVE_MODULE_RELAY) */
408
409 /** Return true iff we are a server and the server identity key
410 * has been set. */
411 int
server_identity_key_is_set(void)412 server_identity_key_is_set(void)
413 {
414 return (server_mode(get_options()) ||
415 get_options()->command == CMD_KEY_EXPIRATION) &&
416 server_identitykey != NULL;
417 }
418
419 /** Set the current client identity key to <b>k</b>.
420 */
421 void
set_client_identity_key(crypto_pk_t * k)422 set_client_identity_key(crypto_pk_t *k)
423 {
424 crypto_pk_free(client_identitykey);
425 client_identitykey = k;
426 }
427
428 /** Returns the current client identity key for use on outgoing TLS
429 * connections; requires that the key has been set.
430 */
431 crypto_pk_t *
get_tlsclient_identity_key(void)432 get_tlsclient_identity_key(void)
433 {
434 tor_assert(client_identitykey);
435 assert_identity_keys_ok();
436 return client_identitykey;
437 }
438
439 /** Return true iff the client identity key has been set. */
440 int
client_identity_key_is_set(void)441 client_identity_key_is_set(void)
442 {
443 return client_identitykey != NULL;
444 }
445
446 /** Return the key certificate for this v3 (voting) authority, or NULL
447 * if we have no such certificate. */
448 MOCK_IMPL(authority_cert_t *,
449 get_my_v3_authority_cert, (void))
450 {
451 return authority_key_certificate;
452 }
453
454 /** Return the v3 signing key for this v3 (voting) authority, or NULL
455 * if we have no such key. */
456 crypto_pk_t *
get_my_v3_authority_signing_key(void)457 get_my_v3_authority_signing_key(void)
458 {
459 return authority_signing_key;
460 }
461
462 /** If we're an authority, and we're using a legacy authority identity key for
463 * emergency migration purposes, return the certificate associated with that
464 * key. */
465 authority_cert_t *
get_my_v3_legacy_cert(void)466 get_my_v3_legacy_cert(void)
467 {
468 return legacy_key_certificate;
469 }
470
471 /** If we're an authority, and we're using a legacy authority identity key for
472 * emergency migration purposes, return that key. */
473 crypto_pk_t *
get_my_v3_legacy_signing_key(void)474 get_my_v3_legacy_signing_key(void)
475 {
476 return legacy_signing_key;
477 }
478
479 /** Replace the previous onion key with the current onion key, and generate
480 * a new previous onion key. Immediately after calling this function,
481 * the OR should:
482 * - schedule all previous cpuworkers to shut down _after_ processing
483 * pending work. (This will cause fresh cpuworkers to be generated.)
484 * - generate and upload a fresh routerinfo.
485 */
486 void
rotate_onion_key(void)487 rotate_onion_key(void)
488 {
489 char *fname, *fname_prev;
490 crypto_pk_t *prkey = NULL;
491 or_state_t *state = get_or_state();
492 curve25519_keypair_t new_curve25519_keypair;
493 time_t now;
494 fname = get_keydir_fname("secret_onion_key");
495 fname_prev = get_keydir_fname("secret_onion_key.old");
496 /* There isn't much point replacing an old key with an empty file */
497 if (file_status(fname) == FN_FILE) {
498 if (replace_file(fname, fname_prev))
499 goto error;
500 }
501 if (!(prkey = crypto_pk_new())) {
502 log_err(LD_GENERAL,"Error constructing rotated onion key");
503 goto error;
504 }
505 if (crypto_pk_generate_key(prkey)) {
506 log_err(LD_BUG,"Error generating onion key");
507 goto error;
508 }
509 if (crypto_pk_write_private_key_to_filename(prkey, fname)) {
510 log_err(LD_FS,"Couldn't write generated onion key to \"%s\".", fname);
511 goto error;
512 }
513 tor_free(fname);
514 tor_free(fname_prev);
515 fname = get_keydir_fname("secret_onion_key_ntor");
516 fname_prev = get_keydir_fname("secret_onion_key_ntor.old");
517 if (curve25519_keypair_generate(&new_curve25519_keypair, 1) < 0)
518 goto error;
519 /* There isn't much point replacing an old key with an empty file */
520 if (file_status(fname) == FN_FILE) {
521 if (replace_file(fname, fname_prev))
522 goto error;
523 }
524 if (curve25519_keypair_write_to_file(&new_curve25519_keypair, fname,
525 "onion") < 0) {
526 log_err(LD_FS,"Couldn't write curve25519 onion key to \"%s\".",fname);
527 goto error;
528 }
529 log_info(LD_GENERAL, "Rotating onion key");
530 tor_mutex_acquire(key_lock);
531 crypto_pk_free(lastonionkey);
532 lastonionkey = onionkey;
533 onionkey = prkey;
534 memcpy(&last_curve25519_onion_key, &curve25519_onion_key,
535 sizeof(curve25519_keypair_t));
536 memcpy(&curve25519_onion_key, &new_curve25519_keypair,
537 sizeof(curve25519_keypair_t));
538 now = time(NULL);
539 state->LastRotatedOnionKey = onionkey_set_at = now;
540 tor_mutex_release(key_lock);
541 mark_my_descriptor_dirty("rotated onion key");
542 or_state_mark_dirty(state, get_options()->AvoidDiskWrites ? now+3600 : 0);
543 goto done;
544 error:
545 log_warn(LD_GENERAL, "Couldn't rotate onion key.");
546 if (prkey)
547 crypto_pk_free(prkey);
548 done:
549 memwipe(&new_curve25519_keypair, 0, sizeof(new_curve25519_keypair));
550 tor_free(fname);
551 tor_free(fname_prev);
552 }
553
554 /** Log greeting message that points to new relay lifecycle document the
555 * first time this function has been called.
556 */
557 static void
log_new_relay_greeting(void)558 log_new_relay_greeting(void)
559 {
560 static int already_logged = 0;
561
562 if (already_logged)
563 return;
564
565 tor_log(LOG_NOTICE, LD_GENERAL, "You are running a new relay. "
566 "Thanks for helping the Tor network! If you wish to know "
567 "what will happen in the upcoming weeks regarding its usage, "
568 "have a look at https://blog.torproject.org/blog/lifecycle-of"
569 "-a-new-relay");
570
571 already_logged = 1;
572 }
573
574 /** Load a curve25519 keypair from the file <b>fname</b>, writing it into
575 * <b>keys_out</b>. If the file isn't found, or is empty, and <b>generate</b>
576 * is true, create a new keypair and write it into the file. If there are
577 * errors, log them at level <b>severity</b>. Generate files using <b>tag</b>
578 * in their ASCII wrapper. */
579 static int
init_curve25519_keypair_from_file(curve25519_keypair_t * keys_out,const char * fname,int generate,int severity,const char * tag)580 init_curve25519_keypair_from_file(curve25519_keypair_t *keys_out,
581 const char *fname,
582 int generate,
583 int severity,
584 const char *tag)
585 {
586 switch (file_status(fname)) {
587 case FN_DIR:
588 case FN_ERROR:
589 tor_log(severity, LD_FS,"Can't read key from \"%s\"", fname);
590 goto error;
591 /* treat empty key files as if the file doesn't exist, and, if generate
592 * is set, replace the empty file in curve25519_keypair_write_to_file() */
593 case FN_NOENT:
594 case FN_EMPTY:
595 if (generate) {
596 if (!have_lockfile()) {
597 if (try_locking(get_options(), 0)<0) {
598 /* Make sure that --list-fingerprint only creates new keys
599 * if there is no possibility for a deadlock. */
600 tor_log(severity, LD_FS, "Another Tor process has locked \"%s\". "
601 "Not writing any new keys.", fname);
602 /*XXXX The 'other process' might make a key in a second or two;
603 * maybe we should wait for it. */
604 goto error;
605 }
606 }
607 log_info(LD_GENERAL, "No key found in \"%s\"; generating fresh key.",
608 fname);
609 if (curve25519_keypair_generate(keys_out, 1) < 0)
610 goto error;
611 if (curve25519_keypair_write_to_file(keys_out, fname, tag)<0) {
612 tor_log(severity, LD_FS,
613 "Couldn't write generated key to \"%s\".", fname);
614 memwipe(keys_out, 0, sizeof(*keys_out));
615 goto error;
616 }
617 } else {
618 log_info(LD_GENERAL, "No key found in \"%s\"", fname);
619 }
620 return 0;
621 case FN_FILE:
622 {
623 char *tag_in=NULL;
624 if (curve25519_keypair_read_from_file(keys_out, &tag_in, fname) < 0) {
625 tor_log(severity, LD_GENERAL,"Error loading private key.");
626 tor_free(tag_in);
627 goto error;
628 }
629 if (!tag_in || strcmp(tag_in, tag)) {
630 tor_log(severity, LD_GENERAL,"Unexpected tag %s on private key.",
631 escaped(tag_in));
632 tor_free(tag_in);
633 goto error;
634 }
635 tor_free(tag_in);
636 return 0;
637 }
638 default:
639 tor_assert(0);
640 }
641
642 error:
643 return -1;
644 }
645
646 /** Try to load the vote-signing private key and certificate for being a v3
647 * directory authority, and make sure they match. If <b>legacy</b>, load a
648 * legacy key/cert set for emergency key migration; otherwise load the regular
649 * key/cert set. On success, store them into *<b>key_out</b> and
650 * *<b>cert_out</b> respectively, and return 0. On failure, return -1. */
651 static int
load_authority_keyset(int legacy,crypto_pk_t ** key_out,authority_cert_t ** cert_out)652 load_authority_keyset(int legacy, crypto_pk_t **key_out,
653 authority_cert_t **cert_out)
654 {
655 int r = -1;
656 char *fname = NULL, *cert = NULL;
657 const char *eos = NULL;
658 crypto_pk_t *signing_key = NULL;
659 authority_cert_t *parsed = NULL;
660
661 fname = get_keydir_fname(
662 legacy ? "legacy_signing_key" : "authority_signing_key");
663 signing_key = init_key_from_file(fname, 0, LOG_ERR, NULL);
664 if (!signing_key) {
665 log_warn(LD_DIR, "No version 3 directory key found in %s", fname);
666 goto done;
667 }
668 tor_free(fname);
669 fname = get_keydir_fname(
670 legacy ? "legacy_certificate" : "authority_certificate");
671 cert = read_file_to_str(fname, 0, NULL);
672 if (!cert) {
673 log_warn(LD_DIR, "Signing key found, but no certificate found in %s",
674 fname);
675 goto done;
676 }
677 parsed = authority_cert_parse_from_string(cert, strlen(cert), &eos);
678 if (!parsed) {
679 log_warn(LD_DIR, "Unable to parse certificate in %s", fname);
680 goto done;
681 }
682 if (!crypto_pk_eq_keys(signing_key, parsed->signing_key)) {
683 log_warn(LD_DIR, "Stored signing key does not match signing key in "
684 "certificate");
685 goto done;
686 }
687
688 crypto_pk_free(*key_out);
689 authority_cert_free(*cert_out);
690
691 *key_out = signing_key;
692 *cert_out = parsed;
693 r = 0;
694 signing_key = NULL;
695 parsed = NULL;
696
697 done:
698 tor_free(fname);
699 tor_free(cert);
700 crypto_pk_free(signing_key);
701 authority_cert_free(parsed);
702 return r;
703 }
704
705 /** Load the v3 (voting) authority signing key and certificate, if they are
706 * present. Return -1 if anything is missing, mismatched, or unloadable;
707 * return 0 on success. */
708 static int
init_v3_authority_keys(void)709 init_v3_authority_keys(void)
710 {
711 if (load_authority_keyset(0, &authority_signing_key,
712 &authority_key_certificate)<0)
713 return -1;
714
715 if (get_options()->V3AuthUseLegacyKey &&
716 load_authority_keyset(1, &legacy_signing_key,
717 &legacy_key_certificate)<0)
718 return -1;
719
720 return 0;
721 }
722
723 /** If we're a v3 authority, check whether we have a certificate that's
724 * likely to expire soon. Warn if we do, but not too often. */
725 void
v3_authority_check_key_expiry(void)726 v3_authority_check_key_expiry(void)
727 {
728 time_t now, expires;
729 static time_t last_warned = 0;
730 int badness, time_left, warn_interval;
731 if (!authdir_mode_v3(get_options()) || !authority_key_certificate)
732 return;
733
734 now = time(NULL);
735 expires = authority_key_certificate->expires;
736 time_left = (int)( expires - now );
737 if (time_left <= 0) {
738 badness = LOG_ERR;
739 warn_interval = 60*60;
740 } else if (time_left <= 24*60*60) {
741 badness = LOG_WARN;
742 warn_interval = 60*60;
743 } else if (time_left <= 24*60*60*7) {
744 badness = LOG_WARN;
745 warn_interval = 24*60*60;
746 } else if (time_left <= 24*60*60*30) {
747 badness = LOG_WARN;
748 warn_interval = 24*60*60*5;
749 } else {
750 return;
751 }
752
753 if (last_warned + warn_interval > now)
754 return;
755
756 if (time_left <= 0) {
757 tor_log(badness, LD_DIR, "Your v3 authority certificate has expired."
758 " Generate a new one NOW.");
759 } else if (time_left <= 24*60*60) {
760 tor_log(badness, LD_DIR, "Your v3 authority certificate expires in %d "
761 "hours; Generate a new one NOW.", time_left/(60*60));
762 } else {
763 tor_log(badness, LD_DIR, "Your v3 authority certificate expires in %d "
764 "days; Generate a new one soon.", time_left/(24*60*60));
765 }
766 last_warned = now;
767 }
768
769 /** Get the lifetime of an onion key in days. This value is defined by the
770 * network consensus parameter "onion-key-rotation-days". Always returns a
771 * value between <b>MIN_ONION_KEY_LIFETIME_DAYS</b> and
772 * <b>MAX_ONION_KEY_LIFETIME_DAYS</b>.
773 */
774 static int
get_onion_key_rotation_days_(void)775 get_onion_key_rotation_days_(void)
776 {
777 return networkstatus_get_param(NULL,
778 "onion-key-rotation-days",
779 DEFAULT_ONION_KEY_LIFETIME_DAYS,
780 MIN_ONION_KEY_LIFETIME_DAYS,
781 MAX_ONION_KEY_LIFETIME_DAYS);
782 }
783
784 /** Get the current lifetime of an onion key in seconds. This value is defined
785 * by the network consensus parameter "onion-key-rotation-days", but the value
786 * is converted to seconds.
787 */
788 int
get_onion_key_lifetime(void)789 get_onion_key_lifetime(void)
790 {
791 return get_onion_key_rotation_days_()*24*60*60;
792 }
793
794 /** Get the grace period of an onion key in seconds. This value is defined by
795 * the network consensus parameter "onion-key-grace-period-days", but the value
796 * is converted to seconds.
797 */
798 int
get_onion_key_grace_period(void)799 get_onion_key_grace_period(void)
800 {
801 int grace_period;
802 grace_period = networkstatus_get_param(NULL,
803 "onion-key-grace-period-days",
804 DEFAULT_ONION_KEY_GRACE_PERIOD_DAYS,
805 MIN_ONION_KEY_GRACE_PERIOD_DAYS,
806 get_onion_key_rotation_days_());
807 return grace_period*24*60*60;
808 }
809
810 /** Set up Tor's TLS contexts, based on our configuration and keys. Return 0
811 * on success, and -1 on failure. */
812 int
router_initialize_tls_context(void)813 router_initialize_tls_context(void)
814 {
815 unsigned int flags = 0;
816 const or_options_t *options = get_options();
817 int lifetime = options->SSLKeyLifetime;
818 if (public_server_mode(options))
819 flags |= TOR_TLS_CTX_IS_PUBLIC_SERVER;
820 if (!lifetime) { /* we should guess a good ssl cert lifetime */
821
822 /* choose between 5 and 365 days, and round to the day */
823 unsigned int five_days = 5*24*3600;
824 unsigned int one_year = 365*24*3600;
825 lifetime = crypto_rand_int_range(five_days, one_year);
826 lifetime -= lifetime % (24*3600);
827
828 if (crypto_rand_int(2)) {
829 /* Half the time we expire at midnight, and half the time we expire
830 * one second before midnight. (Some CAs wobble their expiry times a
831 * bit in practice, perhaps to reduce collision attacks; see ticket
832 * 8443 for details about observed certs in the wild.) */
833 lifetime--;
834 }
835 }
836
837 /* It's ok to pass lifetime in as an unsigned int, since
838 * config_parse_interval() checked it. */
839 return tor_tls_context_init(flags,
840 get_tlsclient_identity_key(),
841 server_mode(options) ?
842 get_server_identity_key() : NULL,
843 (unsigned int)lifetime);
844 }
845
846 /** Announce URL to bridge status page. */
847 STATIC void
router_announce_bridge_status_page(void)848 router_announce_bridge_status_page(void)
849 {
850 char fingerprint[FINGERPRINT_LEN + 1];
851
852 if (crypto_pk_get_hashed_fingerprint(get_server_identity_key(),
853 fingerprint) < 0) {
854 // LCOV_EXCL_START
855 log_err(LD_GENERAL, "Unable to compute bridge fingerprint");
856 return;
857 // LCOV_EXCL_STOP
858 }
859
860 log_notice(LD_GENERAL, "You can check the status of your bridge relay at "
861 "https://bridges.torproject.org/status?id=%s",
862 fingerprint);
863 }
864
865 /** Compute fingerprint (or hashed fingerprint if hashed is 1) and write
866 * it to 'fingerprint' (or 'hashed-fingerprint'). Return 0 on success, or
867 * -1 if Tor should die,
868 */
869 STATIC int
router_write_fingerprint(int hashed,int ed25519_identity)870 router_write_fingerprint(int hashed, int ed25519_identity)
871 {
872 char *keydir = NULL;
873 const char *fname = hashed ? "hashed-fingerprint" :
874 (ed25519_identity ? "fingerprint-ed25519" :
875 "fingerprint");
876 char fingerprint[FINGERPRINT_LEN+1];
877 const or_options_t *options = get_options();
878 char *fingerprint_line = NULL;
879 int result = -1;
880
881 keydir = get_datadir_fname(fname);
882 log_info(LD_GENERAL,"Dumping %s%s to \"%s\"...", hashed ? "hashed " : "",
883 ed25519_identity ? "ed25519 identity" : "fingerprint", keydir);
884
885 if (ed25519_identity) { /* ed25519 identity */
886 digest256_to_base64(fingerprint, (const char *)
887 get_master_identity_key()->pubkey);
888 } else { /* RSA identity */
889 if (!hashed) {
890 if (crypto_pk_get_fingerprint(get_server_identity_key(),
891 fingerprint, 0) < 0) {
892 log_err(LD_GENERAL,"Error computing fingerprint");
893 goto done;
894 }
895 } else {
896 if (crypto_pk_get_hashed_fingerprint(get_server_identity_key(),
897 fingerprint) < 0) {
898 log_err(LD_GENERAL,"Error computing hashed fingerprint");
899 goto done;
900 }
901 }
902 }
903
904 tor_asprintf(&fingerprint_line, "%s %s\n", options->Nickname, fingerprint);
905
906 /* Check whether we need to write the (hashed-)fingerprint file. */
907 if (write_str_to_file_if_not_equal(keydir, fingerprint_line)) {
908 log_err(LD_FS, "Error writing %s%s line to file",
909 hashed ? "hashed " : "",
910 ed25519_identity ? "ed25519 identity" : "fingerprint");
911 goto done;
912 }
913
914 log_notice(LD_GENERAL, "Your Tor %s identity key %s fingerprint is '%s %s'",
915 hashed ? "bridge's hashed" : "server's",
916 ed25519_identity ? "ed25519" : "",
917 options->Nickname, fingerprint);
918
919 result = 0;
920 done:
921 tor_free(keydir);
922 tor_free(fingerprint_line);
923 return result;
924 }
925
926 static int
init_keys_common(void)927 init_keys_common(void)
928 {
929 if (!key_lock)
930 key_lock = tor_mutex_new();
931
932 return 0;
933 }
934
935 int
init_keys_client(void)936 init_keys_client(void)
937 {
938 crypto_pk_t *prkey;
939 if (init_keys_common() < 0)
940 return -1;
941
942 if (!(prkey = crypto_pk_new()))
943 return -1;
944 if (crypto_pk_generate_key(prkey)) {
945 crypto_pk_free(prkey);
946 return -1;
947 }
948 set_client_identity_key(prkey);
949 /* Create a TLS context. */
950 if (router_initialize_tls_context() < 0) {
951 log_err(LD_GENERAL,"Error creating TLS context for Tor client.");
952 return -1;
953 }
954 return 0;
955 }
956
957 /** Initialize all OR private keys, and the TLS context, as necessary.
958 * On OPs, this only initializes the tls context. Return 0 on success,
959 * or -1 if Tor should die.
960 */
961 int
init_keys(void)962 init_keys(void)
963 {
964 char *keydir;
965 const char *mydesc;
966 crypto_pk_t *prkey;
967 char digest[DIGEST_LEN];
968 char v3_digest[DIGEST_LEN];
969 const or_options_t *options = get_options();
970 dirinfo_type_t type;
971 time_t now = time(NULL);
972 dir_server_t *ds;
973 int v3_digest_set = 0;
974 authority_cert_t *cert = NULL;
975
976 /* OP's don't need persistent keys; just make up an identity and
977 * initialize the TLS context. */
978 if (!server_mode(options) && !(options->command == CMD_KEY_EXPIRATION)) {
979 return init_keys_client();
980 }
981 if (init_keys_common() < 0)
982 return -1;
983
984 if (create_keys_directory(options) < 0)
985 return -1;
986
987 /* 1a. Read v3 directory authority key/cert information. */
988 memset(v3_digest, 0, sizeof(v3_digest));
989 if (authdir_mode_v3(options)) {
990 if (init_v3_authority_keys()<0) {
991 log_err(LD_GENERAL, "We're configured as a V3 authority, but we "
992 "were unable to load our v3 authority keys and certificate! "
993 "Use tor-gencert to generate them. Dying.");
994 return -1;
995 }
996 cert = get_my_v3_authority_cert();
997 if (cert) {
998 if (crypto_pk_get_digest(get_my_v3_authority_cert()->identity_key,
999 v3_digest) < 0) {
1000 log_err(LD_BUG, "Couldn't compute my v3 authority identity key "
1001 "digest.");
1002 return -1;
1003 }
1004 v3_digest_set = 1;
1005 }
1006 }
1007
1008 /* 1b. Read identity key. Make it if none is found. */
1009 keydir = get_keydir_fname("secret_id_key");
1010 log_info(LD_GENERAL,"Reading/making identity key \"%s\"...",keydir);
1011 bool created = false;
1012 prkey = init_key_from_file(keydir, 1, LOG_ERR, &created);
1013 tor_free(keydir);
1014 if (!prkey) return -1;
1015 if (created)
1016 log_new_relay_greeting();
1017 set_server_identity_key(prkey);
1018
1019 /* 1c. If we are configured as a bridge, generate a client key;
1020 * otherwise, set the server identity key as our client identity
1021 * key. */
1022 if (public_server_mode(options)) {
1023 set_client_identity_key(crypto_pk_dup_key(prkey)); /* set above */
1024 } else {
1025 if (!(prkey = crypto_pk_new()))
1026 return -1;
1027 if (crypto_pk_generate_key(prkey)) {
1028 crypto_pk_free(prkey);
1029 return -1;
1030 }
1031 set_client_identity_key(prkey);
1032 }
1033
1034 /* 1d. Load all ed25519 keys */
1035 const int new_signing_key = load_ed_keys(options,now);
1036 if (new_signing_key < 0)
1037 return -1;
1038
1039 /* 2. Read onion key. Make it if none is found. */
1040 keydir = get_keydir_fname("secret_onion_key");
1041 log_info(LD_GENERAL,"Reading/making onion key \"%s\"...",keydir);
1042 prkey = init_key_from_file(keydir, 1, LOG_ERR, &created);
1043 if (created)
1044 log_new_relay_greeting();
1045 tor_free(keydir);
1046 if (!prkey) return -1;
1047 set_onion_key(prkey);
1048 if (options->command == CMD_RUN_TOR) {
1049 /* only mess with the state file if we're actually running Tor */
1050 or_state_t *state = get_or_state();
1051 if (state->LastRotatedOnionKey > 100 && state->LastRotatedOnionKey < now) {
1052 /* We allow for some parsing slop, but we don't want to risk accepting
1053 * values in the distant future. If we did, we might never rotate the
1054 * onion key. */
1055 onionkey_set_at = state->LastRotatedOnionKey;
1056 } else {
1057 /* We have no LastRotatedOnionKey set; either we just created the key
1058 * or it's a holdover from 0.1.2.4-alpha-dev or earlier. In either case,
1059 * start the clock ticking now so that we will eventually rotate it even
1060 * if we don't stay up for the full lifetime of an onion key. */
1061 state->LastRotatedOnionKey = onionkey_set_at = now;
1062 or_state_mark_dirty(state, options->AvoidDiskWrites ?
1063 time(NULL)+3600 : 0);
1064 }
1065 }
1066
1067 keydir = get_keydir_fname("secret_onion_key.old");
1068 if (!lastonionkey && file_status(keydir) == FN_FILE) {
1069 /* Load keys from non-empty files only.
1070 * Missing old keys won't be replaced with freshly generated keys. */
1071 prkey = init_key_from_file(keydir, 0, LOG_ERR, 0);
1072 if (prkey)
1073 lastonionkey = prkey;
1074 }
1075 tor_free(keydir);
1076
1077 {
1078 /* 2b. Load curve25519 onion keys. */
1079 int r;
1080 keydir = get_keydir_fname("secret_onion_key_ntor");
1081 r = init_curve25519_keypair_from_file(&curve25519_onion_key,
1082 keydir, 1, LOG_ERR, "onion");
1083 tor_free(keydir);
1084 if (r<0)
1085 return -1;
1086
1087 keydir = get_keydir_fname("secret_onion_key_ntor.old");
1088 if (fast_mem_is_zero((const char *)
1089 last_curve25519_onion_key.pubkey.public_key,
1090 CURVE25519_PUBKEY_LEN) &&
1091 file_status(keydir) == FN_FILE) {
1092 /* Load keys from non-empty files only.
1093 * Missing old keys won't be replaced with freshly generated keys. */
1094 init_curve25519_keypair_from_file(&last_curve25519_onion_key,
1095 keydir, 0, LOG_ERR, "onion");
1096 }
1097 tor_free(keydir);
1098 }
1099
1100 /* 3. Initialize link key and TLS context. */
1101 if (router_initialize_tls_context() < 0) {
1102 log_err(LD_GENERAL,"Error initializing TLS context");
1103 return -1;
1104 }
1105
1106 /* 3b. Get an ed25519 link certificate. Note that we need to do this
1107 * after we set up the TLS context */
1108 if (generate_ed_link_cert(options, now, new_signing_key > 0) < 0) {
1109 log_err(LD_GENERAL,"Couldn't make link cert");
1110 return -1;
1111 }
1112
1113 /* 4. Build our router descriptor. */
1114 /* Must be called after keys are initialized. */
1115 mydesc = router_get_my_descriptor();
1116 if (authdir_mode_v3(options)) {
1117 const char *m = NULL;
1118 routerinfo_t *ri;
1119 /* We need to add our own fingerprint and ed25519 key so it gets
1120 * recognized. */
1121 if (dirserv_add_own_fingerprint(get_server_identity_key(),
1122 get_master_identity_key())) {
1123 log_err(LD_GENERAL,"Error adding own fingerprint to set of relays");
1124 return -1;
1125 }
1126 if (mydesc) {
1127 was_router_added_t added;
1128 ri = router_parse_entry_from_string(mydesc, NULL, 1, 0, NULL, NULL);
1129 if (!ri) {
1130 log_err(LD_GENERAL,"Generated a routerinfo we couldn't parse.");
1131 return -1;
1132 }
1133 added = dirserv_add_descriptor(ri, &m, "self");
1134 if (!WRA_WAS_ADDED(added)) {
1135 if (!WRA_WAS_OUTDATED(added)) {
1136 log_err(LD_GENERAL, "Unable to add own descriptor to directory: %s",
1137 m?m:"<unknown error>");
1138 return -1;
1139 } else {
1140 /* If the descriptor was outdated, that's ok. This can happen
1141 * when some config options are toggled that affect workers, but
1142 * we don't really need new keys yet so the descriptor doesn't
1143 * change and the old one is still fresh. */
1144 log_info(LD_GENERAL, "Couldn't add own descriptor to directory "
1145 "after key init: %s This is usually not a problem.",
1146 m?m:"<unknown error>");
1147 }
1148 }
1149 }
1150 }
1151
1152 /* 5. Dump fingerprint, ed25519 identity and possibly hashed fingerprint
1153 * to files. */
1154 if (router_write_fingerprint(0, 0)) {
1155 log_err(LD_FS, "Error writing fingerprint to file");
1156 return -1;
1157 }
1158 if (!public_server_mode(options) && router_write_fingerprint(1, 0)) {
1159 log_err(LD_FS, "Error writing hashed fingerprint to file");
1160 return -1;
1161 }
1162 if (router_write_fingerprint(0, 1)) {
1163 log_err(LD_FS, "Error writing ed25519 identity to file");
1164 return -1;
1165 }
1166
1167 /* Display URL to bridge status page. */
1168 if (! public_server_mode(options))
1169 router_announce_bridge_status_page();
1170
1171 if (!authdir_mode(options))
1172 return 0;
1173 /* 6. [authdirserver only] load approved-routers file */
1174 if (dirserv_load_fingerprint_file() < 0) {
1175 log_err(LD_GENERAL,"Error loading fingerprints");
1176 return -1;
1177 }
1178 /* 6b. [authdirserver only] add own key to approved directories. */
1179 crypto_pk_get_digest(get_server_identity_key(), digest);
1180 type = ((options->V3AuthoritativeDir ?
1181 (V3_DIRINFO|MICRODESC_DIRINFO|EXTRAINFO_DIRINFO) : NO_DIRINFO) |
1182 (options->BridgeAuthoritativeDir ? BRIDGE_DIRINFO : NO_DIRINFO));
1183
1184 ds = router_get_trusteddirserver_by_digest(digest);
1185 if (!ds) {
1186 tor_addr_port_t ipv6_orport;
1187 routerconf_find_ipv6_or_ap(options, &ipv6_orport);
1188 ds = trusted_dir_server_new(options->Nickname, NULL,
1189 routerconf_find_dir_port(options, 0),
1190 routerconf_find_or_port(options,AF_INET),
1191 &ipv6_orport,
1192 digest,
1193 v3_digest,
1194 type, 0.0);
1195 if (!ds) {
1196 log_err(LD_GENERAL,"We want to be a directory authority, but we "
1197 "couldn't add ourselves to the authority list. Failing.");
1198 return -1;
1199 }
1200 dir_server_add(ds);
1201 }
1202 if (ds->type != type) {
1203 log_warn(LD_DIR, "Configured authority type does not match authority "
1204 "type in DirAuthority list. Adjusting. (%d v %d)",
1205 type, ds->type);
1206 ds->type = type;
1207 }
1208 if (v3_digest_set && (ds->type & V3_DIRINFO) &&
1209 tor_memneq(v3_digest, ds->v3_identity_digest, DIGEST_LEN)) {
1210 log_warn(LD_DIR, "V3 identity key does not match identity declared in "
1211 "DirAuthority line. Adjusting.");
1212 memcpy(ds->v3_identity_digest, v3_digest, DIGEST_LEN);
1213 }
1214
1215 if (cert) { /* add my own cert to the list of known certs */
1216 log_info(LD_DIR, "adding my own v3 cert");
1217 if (trusted_dirs_load_certs_from_string(
1218 cert->cache_info.signed_descriptor_body,
1219 TRUSTED_DIRS_CERTS_SRC_SELF, 0,
1220 NULL)<0) {
1221 log_warn(LD_DIR, "Unable to parse my own v3 cert! Failing.");
1222 return -1;
1223 }
1224 }
1225
1226 return 0; /* success */
1227 }
1228
1229 /** The lower threshold of remaining bandwidth required to advertise (or
1230 * automatically provide) directory services */
1231 /* XXX Should this be increased? */
1232 #define MIN_BW_TO_ADVERTISE_DIRSERVER 51200
1233
1234 /** Return true iff we have enough configured bandwidth to advertise or
1235 * automatically provide directory services from cache directory
1236 * information. */
1237 int
router_has_bandwidth_to_be_dirserver(const or_options_t * options)1238 router_has_bandwidth_to_be_dirserver(const or_options_t *options)
1239 {
1240 if (options->BandwidthRate < MIN_BW_TO_ADVERTISE_DIRSERVER) {
1241 return 0;
1242 }
1243 if (options->RelayBandwidthRate > 0 &&
1244 options->RelayBandwidthRate < MIN_BW_TO_ADVERTISE_DIRSERVER) {
1245 return 0;
1246 }
1247 return 1;
1248 }
1249
1250 /** Helper: Return 1 if we have sufficient resources for serving directory
1251 * requests, return 0 otherwise.
1252 * dir_port is either 0 or the configured DirPort number.
1253 * If AccountingMax is set less than our advertised bandwidth, then don't
1254 * serve requests. Likewise, if our advertised bandwidth is less than
1255 * MIN_BW_TO_ADVERTISE_DIRSERVER, don't bother trying to serve requests.
1256 */
1257 static int
router_should_be_dirserver(const or_options_t * options,int dir_port)1258 router_should_be_dirserver(const or_options_t *options, int dir_port)
1259 {
1260 static int advertising=1; /* start out assuming we will advertise */
1261 int new_choice=1;
1262 const char *reason = NULL;
1263
1264 if (accounting_is_enabled(options) &&
1265 get_options()->AccountingRule != ACCT_IN) {
1266 /* Don't spend bytes for directory traffic if we could end up hibernating,
1267 * but allow DirPort otherwise. Some relay operators set AccountingMax
1268 * because they're confused or to get statistics. Directory traffic has a
1269 * much larger effect on output than input so there is no reason to turn it
1270 * off if using AccountingRule in. */
1271 int interval_length = accounting_get_interval_length();
1272 uint32_t effective_bw = relay_get_effective_bwrate(options);
1273 uint64_t acc_bytes;
1274 if (!interval_length) {
1275 log_warn(LD_BUG, "An accounting interval is not allowed to be zero "
1276 "seconds long. Raising to 1.");
1277 interval_length = 1;
1278 }
1279 log_info(LD_GENERAL, "Calculating whether to advertise %s: effective "
1280 "bwrate: %u, AccountingMax: %"PRIu64", "
1281 "accounting interval length %d",
1282 dir_port ? "dirport" : "begindir",
1283 effective_bw, (options->AccountingMax),
1284 interval_length);
1285
1286 acc_bytes = options->AccountingMax;
1287 if (get_options()->AccountingRule == ACCT_SUM)
1288 acc_bytes /= 2;
1289 if (effective_bw >=
1290 acc_bytes / interval_length) {
1291 new_choice = 0;
1292 reason = "AccountingMax enabled";
1293 }
1294 } else if (! router_has_bandwidth_to_be_dirserver(options)) {
1295 /* if we're advertising a small amount */
1296 new_choice = 0;
1297 reason = "BandwidthRate under 50KB";
1298 }
1299
1300 if (advertising != new_choice) {
1301 if (new_choice == 1) {
1302 if (dir_port > 0)
1303 log_notice(LD_DIR, "Advertising DirPort as %d", dir_port);
1304 else
1305 log_notice(LD_DIR, "Advertising directory service support");
1306 } else {
1307 tor_assert(reason);
1308 log_notice(LD_DIR, "Not advertising Dir%s (Reason: %s)",
1309 dir_port ? "Port" : "ectory Service support", reason);
1310 }
1311 advertising = new_choice;
1312 }
1313
1314 return advertising;
1315 }
1316
1317 /** Look at a variety of factors, and return 0 if we don't want to
1318 * advertise the fact that we have a DirPort open or begindir support, else
1319 * return 1.
1320 *
1321 * Where dir_port or supports_tunnelled_dir_requests are not relevant, they
1322 * must be 0.
1323 *
1324 * Log a helpful message if we change our mind about whether to publish.
1325 */
1326 static int
decide_to_advertise_dir_impl(const or_options_t * options,uint16_t dir_port,int supports_tunnelled_dir_requests)1327 decide_to_advertise_dir_impl(const or_options_t *options,
1328 uint16_t dir_port,
1329 int supports_tunnelled_dir_requests)
1330 {
1331 /* Part one: reasons to publish or not publish that aren't
1332 * worth mentioning to the user, either because they're obvious
1333 * or because they're normal behavior. */
1334
1335 /* short circuit the rest of the function */
1336 if (!dir_port && !supports_tunnelled_dir_requests)
1337 return 0;
1338 if (authdir_mode(options)) /* always publish */
1339 return 1;
1340 if (net_is_disabled())
1341 return 0;
1342 if (dir_port && !routerconf_find_dir_port(options, dir_port))
1343 return 0;
1344 if (supports_tunnelled_dir_requests &&
1345 !routerconf_find_or_port(options, AF_INET))
1346 return 0;
1347
1348 /* Part two: consider config options that could make us choose to
1349 * publish or not publish that the user might find surprising. */
1350 return router_should_be_dirserver(options, dir_port);
1351 }
1352
1353 /** Front-end to decide_to_advertise_dir_impl(): return 0 if we don't want to
1354 * advertise the fact that we have a DirPort open, else return the
1355 * DirPort we want to advertise.
1356 */
1357 int
router_should_advertise_dirport(const or_options_t * options,uint16_t dir_port)1358 router_should_advertise_dirport(const or_options_t *options, uint16_t dir_port)
1359 {
1360 /* Only authorities should advertise a DirPort now. */
1361 return authdir_mode(options) ? dir_port : 0;
1362 }
1363
1364 /** Front-end to decide_to_advertise_dir_impl(): return 0 if we don't want to
1365 * advertise the fact that we support begindir requests, else return 1.
1366 */
1367 static int
router_should_advertise_begindir(const or_options_t * options,int supports_tunnelled_dir_requests)1368 router_should_advertise_begindir(const or_options_t *options,
1369 int supports_tunnelled_dir_requests)
1370 {
1371 /* dir_port is not relevant, pass 0 */
1372 return decide_to_advertise_dir_impl(options, 0,
1373 supports_tunnelled_dir_requests);
1374 }
1375
1376 /** Return true iff the combination of options in <b>options</b> and parameters
1377 * in the consensus mean that we don't want to allow exits from circuits
1378 * we got from addresses not known to be servers. */
1379 int
should_refuse_unknown_exits(const or_options_t * options)1380 should_refuse_unknown_exits(const or_options_t *options)
1381 {
1382 if (options->RefuseUnknownExits != -1) {
1383 return options->RefuseUnknownExits;
1384 } else {
1385 return networkstatus_get_param(NULL, "refuseunknownexits", 1, 0, 1);
1386 }
1387 }
1388
1389 /**
1390 * If true, then we will publish our descriptor even if our own IPv4 ORPort
1391 * seems to be unreachable.
1392 **/
1393 static bool publish_even_when_ipv4_orport_unreachable = false;
1394 /**
1395 * If true, then we will publish our descriptor even if our own IPv6 ORPort
1396 * seems to be unreachable.
1397 **/
1398 static bool publish_even_when_ipv6_orport_unreachable = false;
1399
1400 /** Decide if we're a publishable server. We are a publishable server if:
1401 * - We don't have the ClientOnly option set
1402 * and
1403 * - We have the PublishServerDescriptor option set to non-empty
1404 * and
1405 * - We have ORPort set
1406 * and
1407 * - We believe our ORPort and DirPort (if present) are reachable from
1408 * the outside; or
1409 * - We believe our ORPort is reachable from the outside, and we can't
1410 * check our DirPort because the consensus has no exits; or
1411 * - We are an authoritative directory server.
1412 */
1413 static int
decide_if_publishable_server(void)1414 decide_if_publishable_server(void)
1415 {
1416 const or_options_t *options = get_options();
1417
1418 if (options->ClientOnly)
1419 return 0;
1420 if (options->PublishServerDescriptor_ == NO_DIRINFO)
1421 return 0;
1422 if (!server_mode(options))
1423 return 0;
1424 if (authdir_mode(options))
1425 return 1;
1426 if (!routerconf_find_or_port(options, AF_INET))
1427 return 0;
1428 if (!router_orport_seems_reachable(options, AF_INET)) {
1429 // We have an ipv4 orport, and it doesn't seem reachable.
1430 if (!publish_even_when_ipv4_orport_unreachable) {
1431 return 0;
1432 }
1433 }
1434 /* We could be flagged to omit the IPv6 and if so, don't check for
1435 * reachability on the IPv6. This can happen if the address was
1436 * auto-discovered but turns out to be non reachable. */
1437 if (!omit_ipv6_on_publish &&
1438 !router_orport_seems_reachable(options, AF_INET6)) {
1439 // We have an ipv6 orport, and it doesn't seem reachable.
1440 if (!publish_even_when_ipv6_orport_unreachable) {
1441 return 0;
1442 }
1443 }
1444 if (router_have_consensus_path() == CONSENSUS_PATH_INTERNAL) {
1445 /* All set: there are no exits in the consensus (maybe this is a tiny
1446 * test network), so we can't check our DirPort reachability. */
1447 return 1;
1448 } else {
1449 return router_dirport_seems_reachable(options);
1450 }
1451 }
1452
1453 /** Initiate server descriptor upload as reasonable (if server is publishable,
1454 * etc). <b>force</b> is as for router_upload_dir_desc_to_dirservers.
1455 *
1456 * We need to rebuild the descriptor if it's dirty even if we're not
1457 * uploading, because our reachability testing *uses* our descriptor to
1458 * determine what IP address and ports to test.
1459 */
1460 void
consider_publishable_server(int force)1461 consider_publishable_server(int force)
1462 {
1463 int rebuilt;
1464
1465 if (!server_mode(get_options()))
1466 return;
1467
1468 rebuilt = router_rebuild_descriptor(0);
1469 if (rebuilt && decide_if_publishable_server()) {
1470 set_server_advertised(1);
1471 router_upload_dir_desc_to_dirservers(force);
1472 } else {
1473 set_server_advertised(0);
1474 }
1475 }
1476
1477 /** Return the port of the first active listener of type
1478 * <b>listener_type</b>. Returns 0 if no port is found. */
1479 /** XXX not a very good interface. it's not reliable when there are
1480 multiple listeners. */
1481 uint16_t
router_get_active_listener_port_by_type_af(int listener_type,sa_family_t family)1482 router_get_active_listener_port_by_type_af(int listener_type,
1483 sa_family_t family)
1484 {
1485 /* Iterate all connections, find one of the right kind and return
1486 the port. Not very sophisticated or fast, but effective. */
1487 smartlist_t *conns = get_connection_array();
1488 SMARTLIST_FOREACH_BEGIN(conns, connection_t *, conn) {
1489 if (conn->type == listener_type && !conn->marked_for_close &&
1490 conn->socket_family == family) {
1491 return conn->port;
1492 }
1493 } SMARTLIST_FOREACH_END(conn);
1494
1495 return 0;
1496 }
1497
1498 /** Return the port that we should advertise as our ORPort in a given address
1499 * family; this is either the one configured in the ORPort option, or the one
1500 * we actually bound to if ORPort is "auto". Returns 0 if no port is found. */
1501 uint16_t
routerconf_find_or_port(const or_options_t * options,sa_family_t family)1502 routerconf_find_or_port(const or_options_t *options,
1503 sa_family_t family)
1504 {
1505 int port = portconf_get_first_advertised_port(CONN_TYPE_OR_LISTENER,
1506 family);
1507 (void)options;
1508
1509 /* If the port is in 'auto' mode, we have to use
1510 router_get_listener_port_by_type(). */
1511 if (port == CFG_AUTO_PORT)
1512 return router_get_active_listener_port_by_type_af(CONN_TYPE_OR_LISTENER,
1513 family);
1514
1515 return port;
1516 }
1517
1518 /** As routerconf_find_or_port(), but returns the IPv6 address and
1519 * port in ipv6_ap_out, which must not be NULL. Returns a null address and
1520 * zero port, if no ORPort is found. */
1521 void
routerconf_find_ipv6_or_ap(const or_options_t * options,tor_addr_port_t * ipv6_ap_out)1522 routerconf_find_ipv6_or_ap(const or_options_t *options,
1523 tor_addr_port_t *ipv6_ap_out)
1524 {
1525 /* Bug in calling function, we can't return a sensible result, and it
1526 * shouldn't use the NULL pointer once we return. */
1527 tor_assert(ipv6_ap_out);
1528
1529 /* If there is no valid IPv6 ORPort, return a null address and port. */
1530 tor_addr_make_null(&ipv6_ap_out->addr, AF_INET6);
1531 ipv6_ap_out->port = 0;
1532
1533 const tor_addr_t *addr = portconf_get_first_advertised_addr(
1534 CONN_TYPE_OR_LISTENER,
1535 AF_INET6);
1536 const uint16_t port = routerconf_find_or_port(options,
1537 AF_INET6);
1538
1539 if (!addr || port == 0) {
1540 log_debug(LD_CONFIG, "There is no advertised IPv6 ORPort.");
1541 return;
1542 }
1543
1544 /* If the relay is configured using the default authorities, disallow
1545 * internal IPs. Otherwise, allow them. For IPv4 ORPorts and DirPorts,
1546 * this check is done in resolve_my_address(). See #33681. */
1547 const int default_auth = using_default_dir_authorities(options);
1548 if (tor_addr_is_internal(addr, 0) && default_auth) {
1549 log_warn(LD_CONFIG,
1550 "Unable to use configured IPv6 ORPort \"%s\" in a "
1551 "descriptor. Skipping it. "
1552 "Try specifying a globally reachable address explicitly.",
1553 fmt_addrport(addr, port));
1554 return;
1555 }
1556
1557 tor_addr_copy(&ipv6_ap_out->addr, addr);
1558 ipv6_ap_out->port = port;
1559 }
1560
1561 /** Returns true if this router has an advertised IPv6 ORPort. */
1562 bool
routerconf_has_ipv6_orport(const or_options_t * options)1563 routerconf_has_ipv6_orport(const or_options_t *options)
1564 {
1565 /* What we want here is to learn if we have configured an IPv6 ORPort.
1566 * Remember, ORPort can listen on [::] and thus consider internal by
1567 * router_get_advertised_ipv6_or_ap() since we do _not_ want to advertise
1568 * such address. */
1569 const tor_addr_t *addr =
1570 portconf_get_first_advertised_addr(CONN_TYPE_OR_LISTENER, AF_INET6);
1571 const uint16_t port =
1572 routerconf_find_or_port(options, AF_INET6);
1573
1574 return tor_addr_port_is_valid(addr, port, 1);
1575 }
1576
1577 /** Returns true if this router can extend over IPv6.
1578 *
1579 * This check should only be performed by relay extend code.
1580 *
1581 * Clients should check if relays can initiate and accept IPv6 extends using
1582 * node_supports_initiating_ipv6_extends() and
1583 * node_supports_accepting_ipv6_extends().
1584 *
1585 * As with other extends, relays should assume the client has already
1586 * performed the relevant checks for the next hop. (Otherwise, relays that
1587 * have just added IPv6 ORPorts won't be able to self-test those ORPorts.)
1588 *
1589 * Accepting relays don't need to perform any IPv6-specific checks before
1590 * accepting a connection, because having an IPv6 ORPort implies support for
1591 * the relevant protocol version.
1592 */
1593 MOCK_IMPL(bool,
1594 router_can_extend_over_ipv6,(const or_options_t *options))
1595 {
1596 /* We might add some extra checks here, such as ExtendAllowIPv6Addresses
1597 * from ticket 33818. */
1598 return routerconf_has_ipv6_orport(options);
1599 }
1600
1601 /** Return the port that we should advertise as our DirPort;
1602 * this is one of three possibilities:
1603 * The one that is passed as <b>dirport</b> if the DirPort option is 0, or
1604 * the one configured in the DirPort option,
1605 * or the one we actually bound to if DirPort is "auto". */
1606 uint16_t
routerconf_find_dir_port(const or_options_t * options,uint16_t dirport)1607 routerconf_find_dir_port(const or_options_t *options, uint16_t dirport)
1608 {
1609 int dirport_configured = portconf_get_primary_dir_port();
1610 (void)options;
1611
1612 if (!dirport_configured)
1613 return dirport;
1614
1615 if (dirport_configured == CFG_AUTO_PORT)
1616 return router_get_active_listener_port_by_type_af(CONN_TYPE_DIR_LISTENER,
1617 AF_INET);
1618
1619 return dirport_configured;
1620 }
1621
1622 /*
1623 * OR descriptor generation.
1624 */
1625
1626 /** My routerinfo. */
1627 static routerinfo_t *desc_routerinfo = NULL;
1628 /** My extrainfo */
1629 static extrainfo_t *desc_extrainfo = NULL;
1630 /** Why did we most recently decide to regenerate our descriptor? Used to
1631 * tell the authorities why we're sending it to them. */
1632 static const char *desc_gen_reason = "uninitialized reason";
1633 /** Since when has our descriptor been "clean"? 0 if we need to regenerate it
1634 * now. */
1635 STATIC time_t desc_clean_since = 0;
1636 /** Why did we mark the descriptor dirty? */
1637 STATIC const char *desc_dirty_reason = "Tor just started";
1638 /** Boolean: do we need to regenerate the above? */
1639 static int desc_needs_upload = 0;
1640
1641 /** OR only: If <b>force</b> is true, or we haven't uploaded this
1642 * descriptor successfully yet, try to upload our signed descriptor to
1643 * all the directory servers we know about.
1644 */
1645 void
router_upload_dir_desc_to_dirservers(int force)1646 router_upload_dir_desc_to_dirservers(int force)
1647 {
1648 const routerinfo_t *ri;
1649 extrainfo_t *ei;
1650 char *msg;
1651 size_t desc_len, extra_len = 0, total_len;
1652 dirinfo_type_t auth = get_options()->PublishServerDescriptor_;
1653
1654 ri = router_get_my_routerinfo();
1655 if (!ri) {
1656 log_info(LD_GENERAL, "No descriptor; skipping upload");
1657 return;
1658 }
1659 ei = router_get_my_extrainfo();
1660 if (auth == NO_DIRINFO)
1661 return;
1662 if (!force && !desc_needs_upload)
1663 return;
1664
1665 log_info(LD_OR, "Uploading relay descriptor to directory authorities%s",
1666 force ? " (forced)" : "");
1667
1668 desc_needs_upload = 0;
1669
1670 desc_len = ri->cache_info.signed_descriptor_len;
1671 extra_len = ei ? ei->cache_info.signed_descriptor_len : 0;
1672 total_len = desc_len + extra_len + 1;
1673 msg = tor_malloc(total_len);
1674 memcpy(msg, ri->cache_info.signed_descriptor_body, desc_len);
1675 if (ei) {
1676 memcpy(msg+desc_len, ei->cache_info.signed_descriptor_body, extra_len);
1677 }
1678 msg[desc_len+extra_len] = 0;
1679
1680 directory_post_to_dirservers(DIR_PURPOSE_UPLOAD_DIR,
1681 (auth & BRIDGE_DIRINFO) ?
1682 ROUTER_PURPOSE_BRIDGE :
1683 ROUTER_PURPOSE_GENERAL,
1684 auth, msg, desc_len, extra_len);
1685 tor_free(msg);
1686 }
1687
1688 /** OR only: Check whether my exit policy says to allow connection to
1689 * conn. Return 0 if we accept; non-0 if we reject.
1690 */
1691 int
router_compare_to_my_exit_policy(const tor_addr_t * addr,uint16_t port)1692 router_compare_to_my_exit_policy(const tor_addr_t *addr, uint16_t port)
1693 {
1694 const routerinfo_t *me = router_get_my_routerinfo();
1695 if (!me) /* make sure routerinfo exists */
1696 return -1;
1697
1698 /* make sure it's resolved to something. this way we can't get a
1699 'maybe' below. */
1700 if (tor_addr_is_null(addr))
1701 return -1;
1702
1703 /* look at router_get_my_routerinfo()->exit_policy for both the v4 and the
1704 * v6 policies. The exit_policy field in router_get_my_routerinfo() is a
1705 * bit unusual, in that it contains IPv6 and IPv6 entries. We don't want to
1706 * look at router_get_my_routerinfo()->ipv6_exit_policy, since that's a port
1707 * summary. */
1708 if ((tor_addr_family(addr) == AF_INET ||
1709 tor_addr_family(addr) == AF_INET6)) {
1710 return compare_tor_addr_to_addr_policy(addr, port,
1711 me->exit_policy) != ADDR_POLICY_ACCEPTED;
1712 #if 0
1713 } else if (tor_addr_family(addr) == AF_INET6) {
1714 return get_options()->IPv6Exit &&
1715 desc_routerinfo->ipv6_exit_policy &&
1716 compare_tor_addr_to_short_policy(addr, port,
1717 me->ipv6_exit_policy) != ADDR_POLICY_ACCEPTED;
1718 #endif /* 0 */
1719 } else {
1720 return -1;
1721 }
1722 }
1723
1724 /** Return true iff my exit policy is reject *:*. Return -1 if we don't
1725 * have a descriptor */
1726 MOCK_IMPL(int,
1727 router_my_exit_policy_is_reject_star,(void))
1728 {
1729 const routerinfo_t *me = router_get_my_routerinfo();
1730 if (!me) /* make sure routerinfo exists */
1731 return -1;
1732
1733 return me->policy_is_reject_star;
1734 }
1735
1736 /** Return true iff I'm a server and <b>digest</b> is equal to
1737 * my server identity key digest. */
1738 int
router_digest_is_me(const char * digest)1739 router_digest_is_me(const char *digest)
1740 {
1741 return (server_identitykey &&
1742 tor_memeq(server_identitykey_digest, digest, DIGEST_LEN));
1743 }
1744
1745 /** Return my identity digest. */
1746 const uint8_t *
router_get_my_id_digest(void)1747 router_get_my_id_digest(void)
1748 {
1749 return (const uint8_t *)server_identitykey_digest;
1750 }
1751
1752 /** Return true iff I'm a server and <b>digest</b> is equal to
1753 * my identity digest. */
1754 int
router_extrainfo_digest_is_me(const char * digest)1755 router_extrainfo_digest_is_me(const char *digest)
1756 {
1757 extrainfo_t *ei = router_get_my_extrainfo();
1758 if (!ei)
1759 return 0;
1760
1761 return tor_memeq(digest,
1762 ei->cache_info.signed_descriptor_digest,
1763 DIGEST_LEN);
1764 }
1765
1766 /** A wrapper around router_digest_is_me(). */
1767 int
router_is_me(const routerinfo_t * router)1768 router_is_me(const routerinfo_t *router)
1769 {
1770 return router_digest_is_me(router->cache_info.identity_digest);
1771 }
1772
1773 /**
1774 * Return true if we are a server, and if @a addr is an address we are
1775 * currently publishing (or trying to publish) in our descriptor.
1776 * Return false otherwise.
1777 **/
1778 bool
router_addr_is_my_published_addr(const tor_addr_t * addr)1779 router_addr_is_my_published_addr(const tor_addr_t *addr)
1780 {
1781 IF_BUG_ONCE(!addr)
1782 return false;
1783
1784 const routerinfo_t *me = router_get_my_routerinfo();
1785 if (!me)
1786 return false;
1787
1788 switch (tor_addr_family(addr)) {
1789 case AF_INET:
1790 return tor_addr_eq(addr, &me->ipv4_addr);
1791 case AF_INET6:
1792 return tor_addr_eq(addr, &me->ipv6_addr);
1793 default:
1794 return false;
1795 }
1796 }
1797
1798 /** Return a routerinfo for this OR, rebuilding a fresh one if
1799 * necessary. Return NULL on error, or if called on an OP. */
1800 MOCK_IMPL(const routerinfo_t *,
1801 router_get_my_routerinfo,(void))
1802 {
1803 return router_get_my_routerinfo_with_err(NULL);
1804 }
1805
1806 /** Return routerinfo of this OR. Rebuild it from
1807 * scratch if needed. Set <b>*err</b> to 0 on success or to
1808 * appropriate TOR_ROUTERINFO_ERROR_* value on failure.
1809 */
1810 MOCK_IMPL(const routerinfo_t *,
1811 router_get_my_routerinfo_with_err,(int *err))
1812 {
1813 if (!server_mode(get_options())) {
1814 if (err)
1815 *err = TOR_ROUTERINFO_ERROR_NOT_A_SERVER;
1816
1817 return NULL;
1818 }
1819
1820 if (!desc_routerinfo) {
1821 if (err)
1822 *err = TOR_ROUTERINFO_ERROR_DESC_REBUILDING;
1823
1824 return NULL;
1825 }
1826
1827 if (err)
1828 *err = 0;
1829
1830 return desc_routerinfo;
1831 }
1832
1833 /** OR only: Return a signed server descriptor for this OR, rebuilding a fresh
1834 * one if necessary. Return NULL on error.
1835 */
1836 const char *
router_get_my_descriptor(void)1837 router_get_my_descriptor(void)
1838 {
1839 const char *body;
1840 const routerinfo_t *me = router_get_my_routerinfo();
1841 if (! me)
1842 return NULL;
1843 tor_assert(me->cache_info.saved_location == SAVED_NOWHERE);
1844 body = signed_descriptor_get_body(&me->cache_info);
1845 /* Make sure this is nul-terminated. */
1846 tor_assert(!body[me->cache_info.signed_descriptor_len]);
1847 log_debug(LD_GENERAL,"my desc is '%s'", body);
1848 return body;
1849 }
1850
1851 /** Return the extrainfo document for this OR, or NULL if we have none.
1852 * Rebuilt it (and the server descriptor) if necessary. */
1853 extrainfo_t *
router_get_my_extrainfo(void)1854 router_get_my_extrainfo(void)
1855 {
1856 if (!server_mode(get_options()))
1857 return NULL;
1858 if (!router_rebuild_descriptor(0))
1859 return NULL;
1860 return desc_extrainfo;
1861 }
1862
1863 /** Return a human-readable string describing what triggered us to generate
1864 * our current descriptor, or NULL if we don't know. */
1865 const char *
router_get_descriptor_gen_reason(void)1866 router_get_descriptor_gen_reason(void)
1867 {
1868 return desc_gen_reason;
1869 }
1870
1871 /* Like router_check_descriptor_address_consistency, but specifically for the
1872 * ORPort or DirPort.
1873 * listener_type is either CONN_TYPE_OR_LISTENER or CONN_TYPE_DIR_LISTENER. */
1874 static void
router_check_descriptor_address_port_consistency(const tor_addr_t * addr,int listener_type)1875 router_check_descriptor_address_port_consistency(const tor_addr_t *addr,
1876 int listener_type)
1877 {
1878 int family, port_cfg;
1879
1880 tor_assert(addr);
1881 tor_assert(listener_type == CONN_TYPE_OR_LISTENER ||
1882 listener_type == CONN_TYPE_DIR_LISTENER);
1883
1884 family = tor_addr_family(addr);
1885 /* The first advertised Port may be the magic constant CFG_AUTO_PORT. */
1886 port_cfg = portconf_get_first_advertised_port(listener_type, family);
1887 if (port_cfg != 0 &&
1888 !port_exists_by_type_addr_port(listener_type, addr, port_cfg, 1)) {
1889 const tor_addr_t *port_addr =
1890 portconf_get_first_advertised_addr(listener_type, family);
1891 /* If we're building a descriptor with no advertised address,
1892 * something is terribly wrong. */
1893 tor_assert(port_addr);
1894
1895 char port_addr_str[TOR_ADDR_BUF_LEN];
1896 char desc_addr_str[TOR_ADDR_BUF_LEN];
1897
1898 tor_addr_to_str(port_addr_str, port_addr, TOR_ADDR_BUF_LEN, 0);
1899 tor_addr_to_str(desc_addr_str, addr, TOR_ADDR_BUF_LEN, 0);
1900
1901 const char *listener_str = (listener_type == CONN_TYPE_OR_LISTENER ?
1902 "OR" : "Dir");
1903 const char *af_str = fmt_af_family(family);
1904 log_warn(LD_CONFIG, "The %s %sPort address %s does not match the "
1905 "descriptor address %s. If you have a static public IPv4 "
1906 "address, use 'Address <%s>' and 'OutboundBindAddress "
1907 "<%s>'. If you are behind a NAT, use two %sPort lines: "
1908 "'%sPort <PublicPort> NoListen' and '%sPort <InternalPort> "
1909 "NoAdvertise'.",
1910 af_str, listener_str, port_addr_str, desc_addr_str, af_str,
1911 af_str, listener_str, listener_str, listener_str);
1912 }
1913 }
1914
1915 /** Tor relays only have one IPv4 or/and one IPv6 address in the descriptor,
1916 * which is derived from the Address torrc option, or guessed using various
1917 * methods in relay_find_addr_to_publish().
1918 *
1919 * Warn the operator if there is no ORPort associated with the given address
1920 * in addr.
1921 *
1922 * Warn the operator if there is no DirPort on the descriptor address.
1923 *
1924 * This catches a few common config errors:
1925 * - operators who expect ORPorts and DirPorts to be advertised on the
1926 * ports' listen addresses, rather than the torrc Address (or guessed
1927 * addresses in the absence of an Address config). This includes
1928 * operators who attempt to put their ORPort and DirPort on different
1929 * addresses;
1930 * - discrepancies between guessed addresses and configured listen
1931 * addresses (when the Address option isn't set).
1932 *
1933 * If a listener is listening on all IPv4 addresses, it is assumed that it
1934 * is listening on the configured Address, and no messages are logged.
1935 *
1936 * If an operators has specified NoAdvertise ORPorts in a NAT setting,
1937 * no messages are logged, unless they have specified other advertised
1938 * addresses.
1939 *
1940 * The message tells operators to configure an ORPort and DirPort that match
1941 * the Address (using NoListen if needed). */
1942 static void
router_check_descriptor_address_consistency(const tor_addr_t * addr)1943 router_check_descriptor_address_consistency(const tor_addr_t *addr)
1944 {
1945 router_check_descriptor_address_port_consistency(addr,
1946 CONN_TYPE_OR_LISTENER);
1947 router_check_descriptor_address_port_consistency(addr,
1948 CONN_TYPE_DIR_LISTENER);
1949 }
1950
1951 /** A list of nicknames that we've warned about including in our family,
1952 * for one reason or another. */
1953 static smartlist_t *warned_family = NULL;
1954
1955 /**
1956 * Return a new smartlist containing the family members configured in
1957 * <b>options</b>. Warn about invalid or missing entries. Return NULL
1958 * if this relay should not declare a family.
1959 **/
1960 STATIC smartlist_t *
get_my_declared_family(const or_options_t * options)1961 get_my_declared_family(const or_options_t *options)
1962 {
1963 if (!options->MyFamily)
1964 return NULL;
1965
1966 if (options->BridgeRelay)
1967 return NULL;
1968
1969 if (!warned_family)
1970 warned_family = smartlist_new();
1971
1972 smartlist_t *declared_family = smartlist_new();
1973 config_line_t *family;
1974
1975 /* First we try to get the whole family in the form of hexdigests. */
1976 for (family = options->MyFamily; family; family = family->next) {
1977 char *name = family->value;
1978 const node_t *member;
1979 if (options->Nickname && !strcasecmp(name, options->Nickname))
1980 continue; /* Don't list ourself by nickname, that's redundant */
1981 else
1982 member = node_get_by_nickname(name, 0);
1983
1984 if (!member) {
1985 /* This node doesn't seem to exist, so warn about it if it is not
1986 * a hexdigest. */
1987 int is_legal = is_legal_nickname_or_hexdigest(name);
1988 if (!smartlist_contains_string(warned_family, name) &&
1989 !is_legal_hexdigest(name)) {
1990 if (is_legal)
1991 log_warn(LD_CONFIG,
1992 "There is a router named %s in my declared family, but "
1993 "I have no descriptor for it. I'll use the nickname "
1994 "as is, but this may confuse clients. Please list it "
1995 "by identity digest instead.", escaped(name));
1996 else
1997 log_warn(LD_CONFIG, "There is a router named %s in my declared "
1998 "family, but that isn't a legal digest or nickname. "
1999 "Skipping it.", escaped(name));
2000 smartlist_add_strdup(warned_family, name);
2001 }
2002 if (is_legal) {
2003 smartlist_add_strdup(declared_family, name);
2004 }
2005 } else {
2006 /* List the node by digest. */
2007 char *fp = tor_malloc(HEX_DIGEST_LEN+2);
2008 fp[0] = '$';
2009 base16_encode(fp+1,HEX_DIGEST_LEN+1,
2010 member->identity, DIGEST_LEN);
2011 smartlist_add(declared_family, fp);
2012
2013 if (! is_legal_hexdigest(name) &&
2014 !smartlist_contains_string(warned_family, name)) {
2015 /* Warn if this node was not specified by hexdigest. */
2016 log_warn(LD_CONFIG, "There is a router named %s in my declared "
2017 "family, but it wasn't listed by digest. Please consider "
2018 "saying %s instead, if that's what you meant.",
2019 escaped(name), fp);
2020 smartlist_add_strdup(warned_family, name);
2021 }
2022 }
2023 }
2024
2025 /* Now declared_family should have the closest we can come to the
2026 * identities that the user wanted.
2027 *
2028 * Unlike older versions of Tor, we _do_ include our own identity: this
2029 * helps microdescriptor compression, and helps in-memory compression
2030 * on clients. */
2031 nodefamily_t *nf = nodefamily_from_members(declared_family,
2032 router_get_my_id_digest(),
2033 NF_WARN_MALFORMED,
2034 NULL);
2035 SMARTLIST_FOREACH(declared_family, char *, s, tor_free(s));
2036 smartlist_free(declared_family);
2037 if (!nf) {
2038 return NULL;
2039 }
2040
2041 char *s = nodefamily_format(nf);
2042 nodefamily_free(nf);
2043
2044 smartlist_t *result = smartlist_new();
2045 smartlist_split_string(result, s, NULL,
2046 SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
2047 tor_free(s);
2048
2049 if (smartlist_len(result) == 1) {
2050 /* This is a one-element list containing only ourself; instead return
2051 * nothing */
2052 const char *singleton = smartlist_get(result, 0);
2053 bool is_me = false;
2054 if (singleton[0] == '$') {
2055 char d[DIGEST_LEN];
2056 int n = base16_decode(d, sizeof(d), singleton+1, strlen(singleton+1));
2057 if (n == DIGEST_LEN &&
2058 fast_memeq(d, router_get_my_id_digest(), DIGEST_LEN)) {
2059 is_me = true;
2060 }
2061 }
2062 if (!is_me) {
2063 // LCOV_EXCL_START
2064 log_warn(LD_BUG, "Found a singleton family list with an element "
2065 "that wasn't us! Element was %s", escaped(singleton));
2066 // LCOV_EXCL_STOP
2067 } else {
2068 SMARTLIST_FOREACH(result, char *, cp, tor_free(cp));
2069 smartlist_free(result);
2070 return NULL;
2071 }
2072 }
2073
2074 return result;
2075 }
2076
2077 /** Allocate a fresh, unsigned routerinfo for this OR, without any of the
2078 * fields that depend on the corresponding extrainfo.
2079 *
2080 * On success, set ri_out to the new routerinfo, and return 0.
2081 * Caller is responsible for freeing the generated routerinfo.
2082 *
2083 * Returns a negative value and sets ri_out to NULL on temporary error.
2084 */
2085 MOCK_IMPL(STATIC int,
2086 router_build_fresh_unsigned_routerinfo,(routerinfo_t **ri_out))
2087 {
2088 routerinfo_t *ri = NULL;
2089 tor_addr_t ipv4_addr;
2090 char platform[256];
2091 int hibernating = we_are_hibernating();
2092 const or_options_t *options = get_options();
2093 int result = TOR_ROUTERINFO_ERROR_INTERNAL_BUG;
2094
2095 if (BUG(!ri_out)) {
2096 result = TOR_ROUTERINFO_ERROR_INTERNAL_BUG;
2097 goto err;
2098 }
2099
2100 /* Find our resolved address both IPv4 and IPv6. In case the address is not
2101 * found, the object is set to an UNSPEC address. */
2102 bool have_v4 = relay_find_addr_to_publish(options, AF_INET,
2103 RELAY_FIND_ADDR_NO_FLAG,
2104 &ipv4_addr);
2105 /* Tor requires a relay to have an IPv4 so bail if we can't find it. */
2106 if (!have_v4) {
2107 log_info(LD_CONFIG, "Don't know my address while generating descriptor. "
2108 "Launching circuit to authority to learn it.");
2109 relay_addr_learn_from_dirauth();
2110 result = TOR_ROUTERINFO_ERROR_NO_EXT_ADDR;
2111 goto err;
2112 }
2113 /* Log a message if the address in the descriptor doesn't match the ORPort
2114 * and DirPort addresses configured by the operator. */
2115 router_check_descriptor_address_consistency(&ipv4_addr);
2116
2117 ri = tor_malloc_zero(sizeof(routerinfo_t));
2118 tor_addr_copy(&ri->ipv4_addr, &ipv4_addr);
2119 ri->cache_info.routerlist_index = -1;
2120 ri->nickname = tor_strdup(options->Nickname);
2121
2122 /* IPv4. */
2123 ri->ipv4_orport = routerconf_find_or_port(options, AF_INET);
2124 ri->ipv4_dirport = routerconf_find_dir_port(options, 0);
2125
2126 /* Optionally check for an IPv6. We still publish without one. */
2127 if (relay_find_addr_to_publish(options, AF_INET6, RELAY_FIND_ADDR_NO_FLAG,
2128 &ri->ipv6_addr)) {
2129 ri->ipv6_orport = routerconf_find_or_port(options, AF_INET6);
2130 router_check_descriptor_address_consistency(&ri->ipv6_addr);
2131 }
2132
2133 ri->supports_tunnelled_dir_requests =
2134 directory_permits_begindir_requests(options);
2135 ri->cache_info.published_on = time(NULL);
2136 /* get_onion_key() must invoke from main thread */
2137 router_set_rsa_onion_pkey(get_onion_key(), &ri->onion_pkey,
2138 &ri->onion_pkey_len);
2139
2140 ri->onion_curve25519_pkey =
2141 tor_memdup(&get_current_curve25519_keypair()->pubkey,
2142 sizeof(curve25519_public_key_t));
2143
2144 ri->identity_pkey = crypto_pk_dup_key(get_server_identity_key());
2145 if (BUG(crypto_pk_get_digest(ri->identity_pkey,
2146 ri->cache_info.identity_digest) < 0)) {
2147 result = TOR_ROUTERINFO_ERROR_DIGEST_FAILED;
2148 goto err;
2149 }
2150 ri->cache_info.signing_key_cert =
2151 tor_cert_dup(get_master_signing_key_cert());
2152
2153 get_platform_str(platform, sizeof(platform));
2154 ri->platform = tor_strdup(platform);
2155
2156 ri->protocol_list = tor_strdup(protover_get_supported_protocols());
2157
2158 /* compute ri->bandwidthrate as the min of various options */
2159 ri->bandwidthrate = relay_get_effective_bwrate(options);
2160
2161 /* and compute ri->bandwidthburst similarly */
2162 ri->bandwidthburst = relay_get_effective_bwburst(options);
2163
2164 /* Report bandwidth, unless we're hibernating or shutting down */
2165 ri->bandwidthcapacity = hibernating ? 0 : bwhist_bandwidth_assess();
2166
2167 if (dns_seems_to_be_broken() || has_dns_init_failed()) {
2168 /* DNS is screwed up; don't claim to be an exit. */
2169 policies_exit_policy_append_reject_star(&ri->exit_policy);
2170 } else {
2171 policies_parse_exit_policy_from_options(options, &ri->ipv4_addr,
2172 &ri->ipv6_addr,
2173 &ri->exit_policy);
2174 }
2175 ri->policy_is_reject_star =
2176 policy_is_reject_star(ri->exit_policy, AF_INET, 1) &&
2177 policy_is_reject_star(ri->exit_policy, AF_INET6, 1);
2178
2179 if (options->IPv6Exit) {
2180 char *p_tmp = policy_summarize(ri->exit_policy, AF_INET6);
2181 if (p_tmp)
2182 ri->ipv6_exit_policy = parse_short_policy(p_tmp);
2183 tor_free(p_tmp);
2184 }
2185
2186 ri->declared_family = get_my_declared_family(options);
2187
2188 if (options->BridgeRelay) {
2189 ri->purpose = ROUTER_PURPOSE_BRIDGE;
2190 /* Bridges shouldn't be able to send their descriptors unencrypted,
2191 anyway, since they don't have a DirPort, and always connect to the
2192 bridge authority anonymously. But just in case they somehow think of
2193 sending them on an unencrypted connection, don't allow them to try. */
2194 ri->cache_info.send_unencrypted = 0;
2195 } else {
2196 ri->purpose = ROUTER_PURPOSE_GENERAL;
2197 ri->cache_info.send_unencrypted = 1;
2198 }
2199
2200 goto done;
2201
2202 err:
2203 routerinfo_free(ri);
2204 *ri_out = NULL;
2205 return result;
2206
2207 done:
2208 *ri_out = ri;
2209 return 0;
2210 }
2211
2212 /** Allocate and return a fresh, unsigned extrainfo for this OR, based on the
2213 * routerinfo ri.
2214 *
2215 * Uses options->Nickname to set the nickname, and options->BridgeRelay to set
2216 * ei->cache_info.send_unencrypted.
2217 *
2218 * If ri is NULL, logs a BUG() warning and returns NULL.
2219 * Caller is responsible for freeing the generated extrainfo.
2220 */
2221 static extrainfo_t *
router_build_fresh_unsigned_extrainfo(const routerinfo_t * ri)2222 router_build_fresh_unsigned_extrainfo(const routerinfo_t *ri)
2223 {
2224 extrainfo_t *ei = NULL;
2225 const or_options_t *options = get_options();
2226
2227 if (BUG(!ri))
2228 return NULL;
2229
2230 /* Now generate the extrainfo. */
2231 ei = tor_malloc_zero(sizeof(extrainfo_t));
2232 ei->cache_info.is_extrainfo = 1;
2233 strlcpy(ei->nickname, options->Nickname, sizeof(ei->nickname));
2234 ei->cache_info.published_on = ri->cache_info.published_on;
2235 ei->cache_info.signing_key_cert =
2236 tor_cert_dup(get_master_signing_key_cert());
2237
2238 memcpy(ei->cache_info.identity_digest, ri->cache_info.identity_digest,
2239 DIGEST_LEN);
2240
2241 if (options->BridgeRelay) {
2242 /* See note in router_build_fresh_routerinfo(). */
2243 ei->cache_info.send_unencrypted = 0;
2244 } else {
2245 ei->cache_info.send_unencrypted = 1;
2246 }
2247
2248 return ei;
2249 }
2250
2251 /** Dump the extrainfo descriptor body for ei, sign it, and add the body and
2252 * signature to ei->cache_info. Note that the extrainfo body is determined by
2253 * ei, and some additional config and statistics state: see
2254 * extrainfo_dump_to_string() for details.
2255 *
2256 * Return 0 on success, -1 on temporary error.
2257 * If ei is NULL, logs a BUG() warning and returns -1.
2258 * On error, ei->cache_info is not modified.
2259 */
2260 static int
router_dump_and_sign_extrainfo_descriptor_body(extrainfo_t * ei)2261 router_dump_and_sign_extrainfo_descriptor_body(extrainfo_t *ei)
2262 {
2263 if (BUG(!ei))
2264 return -1;
2265
2266 if (extrainfo_dump_to_string(&ei->cache_info.signed_descriptor_body,
2267 ei, get_server_identity_key(),
2268 get_master_signing_keypair()) < 0) {
2269 log_warn(LD_BUG, "Couldn't generate extra-info descriptor.");
2270 return -1;
2271 }
2272
2273 ei->cache_info.signed_descriptor_len =
2274 strlen(ei->cache_info.signed_descriptor_body);
2275
2276 router_get_extrainfo_hash(ei->cache_info.signed_descriptor_body,
2277 ei->cache_info.signed_descriptor_len,
2278 ei->cache_info.signed_descriptor_digest);
2279 crypto_digest256((char*) ei->digest256,
2280 ei->cache_info.signed_descriptor_body,
2281 ei->cache_info.signed_descriptor_len,
2282 DIGEST_SHA256);
2283
2284 return 0;
2285 }
2286
2287 /** Allocate and return a fresh, signed extrainfo for this OR, based on the
2288 * routerinfo ri.
2289 *
2290 * If ri is NULL, logs a BUG() warning and returns NULL.
2291 * Caller is responsible for freeing the generated extrainfo.
2292 */
2293 STATIC extrainfo_t *
router_build_fresh_signed_extrainfo(const routerinfo_t * ri)2294 router_build_fresh_signed_extrainfo(const routerinfo_t *ri)
2295 {
2296 int result = -1;
2297 extrainfo_t *ei = NULL;
2298
2299 if (BUG(!ri))
2300 return NULL;
2301
2302 ei = router_build_fresh_unsigned_extrainfo(ri);
2303 /* router_build_fresh_unsigned_extrainfo() should not fail. */
2304 if (BUG(!ei))
2305 goto err;
2306
2307 result = router_dump_and_sign_extrainfo_descriptor_body(ei);
2308 if (result < 0)
2309 goto err;
2310
2311 goto done;
2312
2313 err:
2314 extrainfo_free(ei);
2315 return NULL;
2316
2317 done:
2318 return ei;
2319 }
2320
2321 /** Set the fields in ri that depend on ei.
2322 *
2323 * If ei is NULL, logs a BUG() warning and zeroes the relevant fields.
2324 */
2325 STATIC void
router_update_routerinfo_from_extrainfo(routerinfo_t * ri,const extrainfo_t * ei)2326 router_update_routerinfo_from_extrainfo(routerinfo_t *ri,
2327 const extrainfo_t *ei)
2328 {
2329 if (BUG(!ei)) {
2330 /* Just to be safe, zero ri->cache_info.extra_info_digest here. */
2331 memset(ri->cache_info.extra_info_digest, 0, DIGEST_LEN);
2332 memset(ri->cache_info.extra_info_digest256, 0, DIGEST256_LEN);
2333 return;
2334 }
2335
2336 /* Now finish the router descriptor. */
2337 memcpy(ri->cache_info.extra_info_digest,
2338 ei->cache_info.signed_descriptor_digest,
2339 DIGEST_LEN);
2340 memcpy(ri->cache_info.extra_info_digest256,
2341 ei->digest256,
2342 DIGEST256_LEN);
2343 }
2344
2345 /** Dump the descriptor body for ri, sign it, and add the body and signature to
2346 * ri->cache_info. Note that the descriptor body is determined by ri, and some
2347 * additional config and state: see router_dump_router_to_string() for details.
2348 *
2349 * Return 0 on success, and a negative value on temporary error.
2350 * If ri is NULL, logs a BUG() warning and returns a negative value.
2351 * On error, ri->cache_info is not modified.
2352 */
2353 STATIC int
router_dump_and_sign_routerinfo_descriptor_body(routerinfo_t * ri)2354 router_dump_and_sign_routerinfo_descriptor_body(routerinfo_t *ri)
2355 {
2356 if (BUG(!ri))
2357 return TOR_ROUTERINFO_ERROR_INTERNAL_BUG;
2358
2359 if (! (ri->cache_info.signed_descriptor_body =
2360 router_dump_router_to_string(ri, get_server_identity_key(),
2361 get_onion_key(),
2362 get_current_curve25519_keypair(),
2363 get_master_signing_keypair())) ) {
2364 log_warn(LD_BUG, "Couldn't generate router descriptor.");
2365 return TOR_ROUTERINFO_ERROR_CANNOT_GENERATE;
2366 }
2367
2368 ri->cache_info.signed_descriptor_len =
2369 strlen(ri->cache_info.signed_descriptor_body);
2370
2371 router_get_router_hash(ri->cache_info.signed_descriptor_body,
2372 strlen(ri->cache_info.signed_descriptor_body),
2373 ri->cache_info.signed_descriptor_digest);
2374
2375 return 0;
2376 }
2377
2378 /** Build a fresh routerinfo, signed server descriptor, and signed extrainfo
2379 * document for this OR.
2380 *
2381 * Set r to the generated routerinfo, e to the generated extrainfo document.
2382 * Failure to generate an extra-info document is not an error and is indicated
2383 * by setting e to NULL.
2384 * Return 0 on success, and a negative value on temporary error.
2385 * Caller is responsible for freeing generated documents on success.
2386 */
2387 int
router_build_fresh_descriptor(routerinfo_t ** r,extrainfo_t ** e)2388 router_build_fresh_descriptor(routerinfo_t **r, extrainfo_t **e)
2389 {
2390 int result = TOR_ROUTERINFO_ERROR_INTERNAL_BUG;
2391 routerinfo_t *ri = NULL;
2392 extrainfo_t *ei = NULL;
2393
2394 if (BUG(!r))
2395 goto err;
2396
2397 if (BUG(!e))
2398 goto err;
2399
2400 result = router_build_fresh_unsigned_routerinfo(&ri);
2401 if (result < 0) {
2402 goto err;
2403 }
2404 /* If ri is NULL, then result should be negative. So this check should be
2405 * unreachable. */
2406 if (BUG(!ri)) {
2407 result = TOR_ROUTERINFO_ERROR_INTERNAL_BUG;
2408 goto err;
2409 }
2410
2411 ei = router_build_fresh_signed_extrainfo(ri);
2412
2413 /* Failing to create an ei is not an error. */
2414 if (ei) {
2415 router_update_routerinfo_from_extrainfo(ri, ei);
2416 }
2417
2418 result = router_dump_and_sign_routerinfo_descriptor_body(ri);
2419 if (result < 0)
2420 goto err;
2421
2422 if (ei) {
2423 if (BUG(routerinfo_incompatible_with_extrainfo(ri->identity_pkey, ei,
2424 &ri->cache_info, NULL))) {
2425 result = TOR_ROUTERINFO_ERROR_INTERNAL_BUG;
2426 goto err;
2427 }
2428 }
2429
2430 goto done;
2431
2432 err:
2433 routerinfo_free(ri);
2434 extrainfo_free(ei);
2435 *r = NULL;
2436 *e = NULL;
2437 return result;
2438
2439 done:
2440 *r = ri;
2441 *e = ei;
2442 return 0;
2443 }
2444
2445 /** If <b>force</b> is true, or our descriptor is out-of-date, rebuild a fresh
2446 * routerinfo, signed server descriptor, and extra-info document for this OR.
2447 *
2448 * Return true on success, else false on temporary error.
2449 */
2450 bool
router_rebuild_descriptor(int force)2451 router_rebuild_descriptor(int force)
2452 {
2453 int err = 0;
2454 routerinfo_t *ri;
2455 extrainfo_t *ei;
2456
2457 if (desc_clean_since && !force)
2458 return true;
2459
2460 log_info(LD_OR, "Rebuilding relay descriptor%s", force ? " (forced)" : "");
2461
2462 err = router_build_fresh_descriptor(&ri, &ei);
2463 if (err < 0) {
2464 return false;
2465 }
2466
2467 routerinfo_free(desc_routerinfo);
2468 desc_routerinfo = ri;
2469 extrainfo_free(desc_extrainfo);
2470 desc_extrainfo = ei;
2471
2472 desc_clean_since = time(NULL);
2473 desc_needs_upload = 1;
2474 desc_gen_reason = desc_dirty_reason;
2475 if (BUG(desc_gen_reason == NULL)) {
2476 desc_gen_reason = "descriptor was marked dirty earlier, for no reason.";
2477 }
2478 desc_dirty_reason = NULL;
2479 control_event_my_descriptor_changed();
2480 return true;
2481 }
2482
2483 /** Called when we have a new set of consensus parameters. */
2484 void
router_new_consensus_params(const networkstatus_t * ns)2485 router_new_consensus_params(const networkstatus_t *ns)
2486 {
2487 const int32_t DEFAULT_ASSUME_REACHABLE = 0;
2488 const int32_t DEFAULT_ASSUME_REACHABLE_IPV6 = 0;
2489 int ar, ar6;
2490 ar = networkstatus_get_param(ns,
2491 "assume-reachable",
2492 DEFAULT_ASSUME_REACHABLE, 0, 1);
2493 ar6 = networkstatus_get_param(ns,
2494 "assume-reachable-ipv6",
2495 DEFAULT_ASSUME_REACHABLE_IPV6, 0, 1);
2496
2497 publish_even_when_ipv4_orport_unreachable = ar;
2498 publish_even_when_ipv6_orport_unreachable = ar || ar6;
2499 }
2500
2501 /** Mark our descriptor out of data iff the IPv6 omit status flag is flipped
2502 * it changes from its previous value.
2503 *
2504 * This is used when our IPv6 port is found reachable or not. */
2505 void
mark_my_descriptor_if_omit_ipv6_changes(const char * reason,bool omit_ipv6)2506 mark_my_descriptor_if_omit_ipv6_changes(const char *reason, bool omit_ipv6)
2507 {
2508 bool previous = omit_ipv6_on_publish;
2509 omit_ipv6_on_publish = omit_ipv6;
2510
2511 /* Only mark it dirty if the IPv6 omit flag was flipped. */
2512 if (previous != omit_ipv6) {
2513 mark_my_descriptor_dirty(reason);
2514 }
2515 }
2516
2517 /** If our router descriptor ever goes this long without being regenerated
2518 * because something changed, we force an immediate regenerate-and-upload. */
2519 #define FORCE_REGENERATE_DESCRIPTOR_INTERVAL (18*60*60)
2520
2521 /** If our router descriptor seems to be missing or unacceptable according
2522 * to the authorities, regenerate and reupload it _this_ often. */
2523 #define FAST_RETRY_DESCRIPTOR_INTERVAL (90*60)
2524
2525 /** Mark descriptor out of date if it's been "too long" since we last tried
2526 * to upload one. */
2527 void
mark_my_descriptor_dirty_if_too_old(time_t now)2528 mark_my_descriptor_dirty_if_too_old(time_t now)
2529 {
2530 networkstatus_t *ns;
2531 const routerstatus_t *rs;
2532 const char *retry_fast_reason = NULL; /* Set if we should retry frequently */
2533 const time_t slow_cutoff = now - FORCE_REGENERATE_DESCRIPTOR_INTERVAL;
2534 const time_t fast_cutoff = now - FAST_RETRY_DESCRIPTOR_INTERVAL;
2535
2536 /* If it's already dirty, don't mark it. */
2537 if (! desc_clean_since)
2538 return;
2539
2540 /* If it's older than FORCE_REGENERATE_DESCRIPTOR_INTERVAL, it's always
2541 * time to rebuild it. */
2542 if (desc_clean_since < slow_cutoff) {
2543 mark_my_descriptor_dirty("time for new descriptor");
2544 return;
2545 }
2546 /* Now we see whether we want to be retrying frequently or no. The
2547 * rule here is that we'll retry frequently if we aren't listed in the
2548 * live consensus we have, or if the publication time of the
2549 * descriptor listed for us in the consensus is very old, or if the
2550 * consensus lists us as "stale" and we haven't regenerated since the
2551 * consensus was published. */
2552 ns = networkstatus_get_live_consensus(now);
2553 if (ns) {
2554 rs = networkstatus_vote_find_entry(ns, server_identitykey_digest);
2555 if (rs == NULL)
2556 retry_fast_reason = "not listed in consensus";
2557 else if (rs->published_on < slow_cutoff)
2558 retry_fast_reason = "version listed in consensus is quite old";
2559 else if (rs->is_staledesc && ns->valid_after > desc_clean_since)
2560 retry_fast_reason = "listed as stale in consensus";
2561 }
2562
2563 if (retry_fast_reason && desc_clean_since < fast_cutoff)
2564 mark_my_descriptor_dirty(retry_fast_reason);
2565 }
2566
2567 /** Call when the current descriptor is out of date. */
2568 void
mark_my_descriptor_dirty(const char * reason)2569 mark_my_descriptor_dirty(const char *reason)
2570 {
2571 const or_options_t *options = get_options();
2572 if (BUG(reason == NULL)) {
2573 reason = "marked descriptor dirty for unspecified reason";
2574 }
2575 if (server_mode(options) && options->PublishServerDescriptor_) {
2576 log_info(LD_OR, "Decided to publish new relay descriptor: %s", reason);
2577 }
2578 desc_clean_since = 0;
2579 if (!desc_dirty_reason)
2580 desc_dirty_reason = reason;
2581 reschedule_descriptor_update_check();
2582 }
2583
2584 /** How frequently will we republish our descriptor because of large (factor
2585 * of 2) shifts in estimated bandwidth? Note: We don't use this constant
2586 * if our previous bandwidth estimate was exactly 0. */
2587 #define MAX_BANDWIDTH_CHANGE_FREQ (3*60*60)
2588
2589 /** Maximum uptime to republish our descriptor because of large shifts in
2590 * estimated bandwidth. */
2591 #define MAX_UPTIME_BANDWIDTH_CHANGE (24*60*60)
2592
2593 /** By which factor bandwidth shifts have to change to be considered large. */
2594 #define BANDWIDTH_CHANGE_FACTOR 2
2595
2596 /** Check whether bandwidth has changed a lot since the last time we announced
2597 * bandwidth while the uptime is smaller than MAX_UPTIME_BANDWIDTH_CHANGE.
2598 * If so, mark our descriptor dirty. */
2599 void
check_descriptor_bandwidth_changed(time_t now)2600 check_descriptor_bandwidth_changed(time_t now)
2601 {
2602 static time_t last_changed = 0;
2603 uint64_t prev, cur;
2604 const int hibernating = we_are_hibernating();
2605
2606 /* If the relay uptime is bigger than MAX_UPTIME_BANDWIDTH_CHANGE,
2607 * the next regularly scheduled descriptor update (18h) will be enough */
2608 if (get_uptime() > MAX_UPTIME_BANDWIDTH_CHANGE && !hibernating)
2609 return;
2610
2611 const routerinfo_t *my_ri = router_get_my_routerinfo();
2612
2613 if (!my_ri)
2614 return;
2615
2616 prev = my_ri->bandwidthcapacity;
2617
2618 /* Consider ourselves to have zero bandwidth if we're hibernating or
2619 * shutting down. */
2620 cur = hibernating ? 0 : bwhist_bandwidth_assess();
2621
2622 if ((prev != cur && (!prev || !cur)) ||
2623 cur > (prev * BANDWIDTH_CHANGE_FACTOR) ||
2624 cur < (prev / BANDWIDTH_CHANGE_FACTOR) ) {
2625 const bool change_recent_enough =
2626 last_changed+MAX_BANDWIDTH_CHANGE_FREQ < now;
2627 const bool testing_network = get_options()->TestingTorNetwork;
2628 if (change_recent_enough || testing_network || !prev) {
2629 log_info(LD_GENERAL,
2630 "Measured bandwidth has changed; rebuilding descriptor.");
2631 mark_my_descriptor_dirty("bandwidth has changed");
2632 last_changed = now;
2633 }
2634 }
2635 }
2636
2637 // This function can be "noreturn" if relay mode is disabled and
2638 // ALL_BUGS_ARE_FATAL is set.
2639 DISABLE_GCC_WARNING("-Wmissing-noreturn")
2640
2641 /** Note at log level severity that our best guess of address has changed from
2642 * <b>prev</b> to <b>cur</b>. */
2643 void
log_addr_has_changed(int severity,const tor_addr_t * prev,const tor_addr_t * cur,const char * source)2644 log_addr_has_changed(int severity,
2645 const tor_addr_t *prev,
2646 const tor_addr_t *cur,
2647 const char *source)
2648 {
2649 char addrbuf_prev[TOR_ADDR_BUF_LEN];
2650 char addrbuf_cur[TOR_ADDR_BUF_LEN];
2651
2652 if (BUG(!server_mode(get_options())))
2653 return;
2654
2655 if (tor_addr_to_str(addrbuf_prev, prev, sizeof(addrbuf_prev), 1) == NULL)
2656 strlcpy(addrbuf_prev, "???", TOR_ADDR_BUF_LEN);
2657 if (tor_addr_to_str(addrbuf_cur, cur, sizeof(addrbuf_cur), 1) == NULL)
2658 strlcpy(addrbuf_cur, "???", TOR_ADDR_BUF_LEN);
2659
2660 if (!tor_addr_is_null(prev))
2661 log_fn(severity, LD_GENERAL,
2662 "Our IP Address has changed from %s to %s; "
2663 "rebuilding descriptor (source: %s).",
2664 addrbuf_prev, addrbuf_cur, source);
2665 else
2666 log_notice(LD_GENERAL,
2667 "Guessed our IP address as %s (source: %s).",
2668 addrbuf_cur, source);
2669 }
2670 ENABLE_GCC_WARNING("-Wmissing-noreturn")
2671
2672 /** Check whether our own address has changed versus the one we have in our
2673 * current descriptor.
2674 *
2675 * If our address has changed, call ip_address_changed() which takes
2676 * appropriate actions. */
2677 void
check_descriptor_ipaddress_changed(time_t now)2678 check_descriptor_ipaddress_changed(time_t now)
2679 {
2680 const routerinfo_t *my_ri = router_get_my_routerinfo();
2681 resolved_addr_method_t method = RESOLVED_ADDR_NONE;
2682 char *hostname = NULL;
2683 int families[2] = { AF_INET, AF_INET6 };
2684 bool has_changed = false;
2685
2686 (void) now;
2687
2688 /* We can't learn our descriptor address without one. */
2689 if (my_ri == NULL) {
2690 return;
2691 }
2692
2693 for (size_t i = 0; i < ARRAY_LENGTH(families); i++) {
2694 tor_addr_t current;
2695 const tor_addr_t *previous;
2696 int family = families[i];
2697
2698 /* Get the descriptor address from the family we are looking up. */
2699 previous = &my_ri->ipv4_addr;
2700 if (family == AF_INET6) {
2701 previous = &my_ri->ipv6_addr;
2702 }
2703
2704 /* Attempt to discovery the publishable address for the family which will
2705 * actively attempt to discover the address if we are configured with a
2706 * port for the family.
2707 *
2708 * It is OK to ignore the returned value here since in the failure case,
2709 * that is the address was not found, the current value is set to UNSPEC.
2710 * Add this (void) so Coverity is happy. */
2711 (void) relay_find_addr_to_publish(get_options(), family,
2712 RELAY_FIND_ADDR_NO_FLAG, ¤t);
2713
2714 /* The "current" address might be UNSPEC meaning it was not discovered nor
2715 * found in our current cache. If we had an address before and we have
2716 * none now, we consider this an IP change since it appears the relay lost
2717 * its address. */
2718
2719 if (!tor_addr_eq(previous, ¤t)) {
2720 char *source;
2721 tor_asprintf(&source, "METHOD=%s%s%s",
2722 resolved_addr_method_to_str(method),
2723 hostname ? " HOSTNAME=" : "",
2724 hostname ? hostname : "");
2725 log_addr_has_changed(LOG_NOTICE, previous, ¤t, source);
2726 tor_free(source);
2727 has_changed = true;
2728 }
2729 tor_free(hostname);
2730 }
2731
2732 if (has_changed) {
2733 ip_address_changed(0);
2734 }
2735 }
2736
2737 /** Set <b>platform</b> (max length <b>len</b>) to a NUL-terminated short
2738 * string describing the version of Tor and the operating system we're
2739 * currently running on.
2740 */
2741 STATIC void
get_platform_str(char * platform,size_t len)2742 get_platform_str(char *platform, size_t len)
2743 {
2744 tor_snprintf(platform, len, "Tor %s on %s",
2745 get_short_version(), get_uname());
2746 }
2747
2748 /* XXX need to audit this thing and count fenceposts. maybe
2749 * refactor so we don't have to keep asking if we're
2750 * near the end of maxlen?
2751 */
2752 #define DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
2753
2754 /** OR only: Given a routerinfo for this router, and an identity key to sign
2755 * with, encode the routerinfo as a signed server descriptor and return a new
2756 * string encoding the result, or NULL on failure.
2757 *
2758 * In addition to the fields in router, this function calls
2759 * onion_key_lifetime(), get_options(), and we_are_hibernating(), and uses the
2760 * results to populate some fields in the descriptor.
2761 */
2762 char *
router_dump_router_to_string(routerinfo_t * router,const crypto_pk_t * ident_key,const crypto_pk_t * tap_key,const curve25519_keypair_t * ntor_keypair,const ed25519_keypair_t * signing_keypair)2763 router_dump_router_to_string(routerinfo_t *router,
2764 const crypto_pk_t *ident_key,
2765 const crypto_pk_t *tap_key,
2766 const curve25519_keypair_t *ntor_keypair,
2767 const ed25519_keypair_t *signing_keypair)
2768 {
2769 char *address = NULL;
2770 char *onion_pkey = NULL; /* Onion key, PEM-encoded. */
2771 crypto_pk_t *rsa_pubkey = NULL;
2772 char *identity_pkey = NULL; /* Identity key, PEM-encoded. */
2773 char digest[DIGEST256_LEN];
2774 char published[ISO_TIME_LEN+1];
2775 char fingerprint[FINGERPRINT_LEN+1];
2776 char *extra_info_line = NULL;
2777 size_t onion_pkeylen, identity_pkeylen;
2778 char *family_line = NULL;
2779 char *extra_or_address = NULL;
2780 const or_options_t *options = get_options();
2781 smartlist_t *chunks = NULL;
2782 char *output = NULL;
2783 const int emit_ed_sigs = signing_keypair &&
2784 router->cache_info.signing_key_cert;
2785 char *ed_cert_line = NULL;
2786 char *rsa_tap_cc_line = NULL;
2787 char *ntor_cc_line = NULL;
2788 char *proto_line = NULL;
2789
2790 /* Make sure the identity key matches the one in the routerinfo. */
2791 if (!crypto_pk_eq_keys(ident_key, router->identity_pkey)) {
2792 log_warn(LD_BUG,"Tried to sign a router with a private key that didn't "
2793 "match router's public key!");
2794 goto err;
2795 }
2796 if (emit_ed_sigs) {
2797 if (!router->cache_info.signing_key_cert->signing_key_included ||
2798 !ed25519_pubkey_eq(&router->cache_info.signing_key_cert->signed_key,
2799 &signing_keypair->pubkey)) {
2800 log_warn(LD_BUG, "Tried to sign a router descriptor with a mismatched "
2801 "ed25519 key chain %d",
2802 router->cache_info.signing_key_cert->signing_key_included);
2803 goto err;
2804 }
2805 }
2806
2807 /* record our fingerprint, so we can include it in the descriptor */
2808 if (crypto_pk_get_fingerprint(router->identity_pkey, fingerprint, 1)<0) {
2809 log_err(LD_BUG,"Error computing fingerprint");
2810 goto err;
2811 }
2812
2813 if (emit_ed_sigs) {
2814 /* Encode ed25519 signing cert */
2815 char ed_cert_base64[256];
2816 char ed_fp_base64[ED25519_BASE64_LEN+1];
2817 if (base64_encode(ed_cert_base64, sizeof(ed_cert_base64),
2818 (const char*)router->cache_info.signing_key_cert->encoded,
2819 router->cache_info.signing_key_cert->encoded_len,
2820 BASE64_ENCODE_MULTILINE) < 0) {
2821 log_err(LD_BUG,"Couldn't base64-encode signing key certificate!");
2822 goto err;
2823 }
2824 ed25519_public_to_base64(ed_fp_base64,
2825 &router->cache_info.signing_key_cert->signing_key);
2826 tor_asprintf(&ed_cert_line, "identity-ed25519\n"
2827 "-----BEGIN ED25519 CERT-----\n"
2828 "%s"
2829 "-----END ED25519 CERT-----\n"
2830 "master-key-ed25519 %s\n",
2831 ed_cert_base64, ed_fp_base64);
2832 }
2833
2834 /* PEM-encode the onion key */
2835 rsa_pubkey = router_get_rsa_onion_pkey(router->onion_pkey,
2836 router->onion_pkey_len);
2837 if (crypto_pk_write_public_key_to_string(rsa_pubkey,
2838 &onion_pkey,&onion_pkeylen)<0) {
2839 log_warn(LD_BUG,"write onion_pkey to string failed!");
2840 goto err;
2841 }
2842
2843 /* PEM-encode the identity key */
2844 if (crypto_pk_write_public_key_to_string(router->identity_pkey,
2845 &identity_pkey,&identity_pkeylen)<0) {
2846 log_warn(LD_BUG,"write identity_pkey to string failed!");
2847 goto err;
2848 }
2849
2850 /* Cross-certify with RSA key */
2851 if (tap_key && router->cache_info.signing_key_cert &&
2852 router->cache_info.signing_key_cert->signing_key_included) {
2853 char buf[256];
2854 int tap_cc_len = 0;
2855 uint8_t *tap_cc =
2856 make_tap_onion_key_crosscert(tap_key,
2857 &router->cache_info.signing_key_cert->signing_key,
2858 router->identity_pkey,
2859 &tap_cc_len);
2860 if (!tap_cc) {
2861 log_warn(LD_BUG,"make_tap_onion_key_crosscert failed!");
2862 goto err;
2863 }
2864
2865 if (base64_encode(buf, sizeof(buf), (const char*)tap_cc, tap_cc_len,
2866 BASE64_ENCODE_MULTILINE) < 0) {
2867 log_warn(LD_BUG,"base64_encode(rsa_crosscert) failed!");
2868 tor_free(tap_cc);
2869 goto err;
2870 }
2871 tor_free(tap_cc);
2872
2873 tor_asprintf(&rsa_tap_cc_line,
2874 "onion-key-crosscert\n"
2875 "-----BEGIN CROSSCERT-----\n"
2876 "%s"
2877 "-----END CROSSCERT-----\n", buf);
2878 }
2879
2880 /* Cross-certify with onion keys */
2881 if (ntor_keypair && router->cache_info.signing_key_cert &&
2882 router->cache_info.signing_key_cert->signing_key_included) {
2883 int sign = 0;
2884 char buf[256];
2885 /* XXXX Base the expiration date on the actual onion key expiration time?*/
2886 tor_cert_t *cert =
2887 make_ntor_onion_key_crosscert(ntor_keypair,
2888 &router->cache_info.signing_key_cert->signing_key,
2889 router->cache_info.published_on,
2890 get_onion_key_lifetime(), &sign);
2891 if (!cert) {
2892 log_warn(LD_BUG,"make_ntor_onion_key_crosscert failed!");
2893 goto err;
2894 }
2895 tor_assert(sign == 0 || sign == 1);
2896
2897 if (base64_encode(buf, sizeof(buf),
2898 (const char*)cert->encoded, cert->encoded_len,
2899 BASE64_ENCODE_MULTILINE)<0) {
2900 log_warn(LD_BUG,"base64_encode(ntor_crosscert) failed!");
2901 tor_cert_free(cert);
2902 goto err;
2903 }
2904 tor_cert_free(cert);
2905
2906 tor_asprintf(&ntor_cc_line,
2907 "ntor-onion-key-crosscert %d\n"
2908 "-----BEGIN ED25519 CERT-----\n"
2909 "%s"
2910 "-----END ED25519 CERT-----\n", sign, buf);
2911 }
2912
2913 /* Encode the publication time. */
2914 format_iso_time(published, router->cache_info.published_on);
2915
2916 if (router->declared_family && smartlist_len(router->declared_family)) {
2917 char *family = smartlist_join_strings(router->declared_family,
2918 " ", 0, NULL);
2919 tor_asprintf(&family_line, "family %s\n", family);
2920 tor_free(family);
2921 } else {
2922 family_line = tor_strdup("");
2923 }
2924
2925 if (!tor_digest_is_zero(router->cache_info.extra_info_digest)) {
2926 char extra_info_digest[HEX_DIGEST_LEN+1];
2927 base16_encode(extra_info_digest, sizeof(extra_info_digest),
2928 router->cache_info.extra_info_digest, DIGEST_LEN);
2929 if (!tor_digest256_is_zero(router->cache_info.extra_info_digest256)) {
2930 char d256_64[BASE64_DIGEST256_LEN+1];
2931 digest256_to_base64(d256_64, router->cache_info.extra_info_digest256);
2932 tor_asprintf(&extra_info_line, "extra-info-digest %s %s\n",
2933 extra_info_digest, d256_64);
2934 } else {
2935 tor_asprintf(&extra_info_line, "extra-info-digest %s\n",
2936 extra_info_digest);
2937 }
2938 }
2939
2940 if (!omit_ipv6_on_publish && router->ipv6_orport &&
2941 tor_addr_family(&router->ipv6_addr) == AF_INET6) {
2942 char addr[TOR_ADDR_BUF_LEN];
2943 const char *a;
2944 a = tor_addr_to_str(addr, &router->ipv6_addr, sizeof(addr), 1);
2945 if (a) {
2946 tor_asprintf(&extra_or_address,
2947 "or-address %s:%d\n", a, router->ipv6_orport);
2948 log_debug(LD_OR, "My or-address line is <%s>", extra_or_address);
2949 }
2950 }
2951
2952 if (router->protocol_list) {
2953 tor_asprintf(&proto_line, "proto %s\n", router->protocol_list);
2954 } else {
2955 proto_line = tor_strdup("");
2956 }
2957
2958 address = tor_addr_to_str_dup(&router->ipv4_addr);
2959 if (!address)
2960 goto err;
2961
2962 chunks = smartlist_new();
2963
2964 /* Generate the easy portion of the router descriptor. */
2965 smartlist_add_asprintf(chunks,
2966 "router %s %s %d 0 %d\n"
2967 "%s"
2968 "%s"
2969 "platform %s\n"
2970 "%s"
2971 "published %s\n"
2972 "fingerprint %s\n"
2973 "uptime %ld\n"
2974 "bandwidth %d %d %d\n"
2975 "%s%s"
2976 "onion-key\n%s"
2977 "signing-key\n%s"
2978 "%s%s"
2979 "%s%s%s",
2980 router->nickname,
2981 address,
2982 router->ipv4_orport,
2983 router_should_advertise_dirport(options, router->ipv4_dirport),
2984 ed_cert_line ? ed_cert_line : "",
2985 extra_or_address ? extra_or_address : "",
2986 router->platform,
2987 proto_line,
2988 published,
2989 fingerprint,
2990 get_uptime(),
2991 (int) router->bandwidthrate,
2992 (int) router->bandwidthburst,
2993 (int) router->bandwidthcapacity,
2994 extra_info_line ? extra_info_line : "",
2995 (options->DownloadExtraInfo || options->V3AuthoritativeDir) ?
2996 "caches-extra-info\n" : "",
2997 onion_pkey, identity_pkey,
2998 rsa_tap_cc_line ? rsa_tap_cc_line : "",
2999 ntor_cc_line ? ntor_cc_line : "",
3000 family_line,
3001 we_are_hibernating() ? "hibernating 1\n" : "",
3002 "hidden-service-dir\n");
3003
3004 if (options->ContactInfo && strlen(options->ContactInfo)) {
3005 const char *ci = options->ContactInfo;
3006 if (strchr(ci, '\n') || strchr(ci, '\r'))
3007 ci = escaped(ci);
3008 smartlist_add_asprintf(chunks, "contact %s\n", ci);
3009 }
3010
3011 if (options->BridgeRelay) {
3012 char *bd = NULL;
3013
3014 if (options->BridgeDistribution && strlen(options->BridgeDistribution)) {
3015 bd = tor_strdup(options->BridgeDistribution);
3016 } else {
3017 bd = tor_strdup("any");
3018 }
3019
3020 // Make sure our value is lowercased in the descriptor instead of just
3021 // forwarding what the user wrote in their torrc directly.
3022 tor_strlower(bd);
3023
3024 smartlist_add_asprintf(chunks, "bridge-distribution-request %s\n", bd);
3025 tor_free(bd);
3026 }
3027
3028 if (router->onion_curve25519_pkey) {
3029 char kbuf[CURVE25519_BASE64_PADDED_LEN + 1];
3030 curve25519_public_to_base64(kbuf, router->onion_curve25519_pkey, false);
3031 smartlist_add_asprintf(chunks, "ntor-onion-key %s\n", kbuf);
3032 } else {
3033 /* Authorities will start rejecting relays without ntor keys in 0.2.9 */
3034 log_err(LD_BUG, "A relay must have an ntor onion key");
3035 goto err;
3036 }
3037
3038 /* Write the exit policy to the end of 's'. */
3039 if (!router->exit_policy || !smartlist_len(router->exit_policy)) {
3040 smartlist_add_strdup(chunks, "reject *:*\n");
3041 } else if (router->exit_policy) {
3042 char *exit_policy = router_dump_exit_policy_to_string(router,1,0);
3043
3044 if (!exit_policy)
3045 goto err;
3046
3047 smartlist_add_asprintf(chunks, "%s\n", exit_policy);
3048 tor_free(exit_policy);
3049 }
3050
3051 if (router->ipv6_exit_policy) {
3052 char *p6 = write_short_policy(router->ipv6_exit_policy);
3053 if (p6 && strcmp(p6, "reject 1-65535")) {
3054 smartlist_add_asprintf(chunks,
3055 "ipv6-policy %s\n", p6);
3056 }
3057 tor_free(p6);
3058 }
3059
3060 if (router_should_advertise_begindir(options,
3061 router->supports_tunnelled_dir_requests)) {
3062 smartlist_add_strdup(chunks, "tunnelled-dir-server\n");
3063 }
3064
3065 /* Overload general information. */
3066 if (options->OverloadStatistics) {
3067 char *overload_general = rep_hist_get_overload_general_line();
3068
3069 if (overload_general) {
3070 smartlist_add(chunks, overload_general);
3071 }
3072 }
3073
3074 /* Sign the descriptor with Ed25519 */
3075 if (emit_ed_sigs) {
3076 smartlist_add_strdup(chunks, "router-sig-ed25519 ");
3077 crypto_digest_smartlist_prefix(digest, DIGEST256_LEN,
3078 ED_DESC_SIGNATURE_PREFIX,
3079 chunks, "", DIGEST_SHA256);
3080 ed25519_signature_t sig;
3081 char buf[ED25519_SIG_BASE64_LEN+1];
3082 if (ed25519_sign(&sig, (const uint8_t*)digest, DIGEST256_LEN,
3083 signing_keypair) < 0)
3084 goto err;
3085 ed25519_signature_to_base64(buf, &sig);
3086
3087 smartlist_add_asprintf(chunks, "%s\n", buf);
3088 }
3089
3090 /* Sign the descriptor with RSA */
3091 smartlist_add_strdup(chunks, "router-signature\n");
3092
3093 crypto_digest_smartlist(digest, DIGEST_LEN, chunks, "", DIGEST_SHA1);
3094
3095 {
3096 char *sig;
3097 if (!(sig = router_get_dirobj_signature(digest, DIGEST_LEN, ident_key))) {
3098 log_warn(LD_BUG, "Couldn't sign router descriptor");
3099 goto err;
3100 }
3101 smartlist_add(chunks, sig);
3102 }
3103
3104 /* include a last '\n' */
3105 smartlist_add_strdup(chunks, "\n");
3106
3107 output = smartlist_join_strings(chunks, "", 0, NULL);
3108
3109 #ifdef DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
3110 {
3111 char *s_dup;
3112 const char *cp;
3113 routerinfo_t *ri_tmp;
3114 cp = s_dup = tor_strdup(output);
3115 ri_tmp = router_parse_entry_from_string(cp, NULL, 1, 0, NULL, NULL);
3116 if (!ri_tmp) {
3117 log_err(LD_BUG,
3118 "We just generated a router descriptor we can't parse.");
3119 log_err(LD_BUG, "Descriptor was: <<%s>>", output);
3120 goto err;
3121 }
3122 tor_free(s_dup);
3123 routerinfo_free(ri_tmp);
3124 }
3125 #endif /* defined(DEBUG_ROUTER_DUMP_ROUTER_TO_STRING) */
3126
3127 goto done;
3128
3129 err:
3130 tor_free(output); /* sets output to NULL */
3131 done:
3132 if (chunks) {
3133 SMARTLIST_FOREACH(chunks, char *, cp, tor_free(cp));
3134 smartlist_free(chunks);
3135 }
3136 crypto_pk_free(rsa_pubkey);
3137 tor_free(address);
3138 tor_free(family_line);
3139 tor_free(onion_pkey);
3140 tor_free(identity_pkey);
3141 tor_free(extra_or_address);
3142 tor_free(ed_cert_line);
3143 tor_free(rsa_tap_cc_line);
3144 tor_free(ntor_cc_line);
3145 tor_free(extra_info_line);
3146 tor_free(proto_line);
3147
3148 return output;
3149 }
3150
3151 /**
3152 * OR only: Given <b>router</b>, produce a string with its exit policy.
3153 * If <b>include_ipv4</b> is true, include IPv4 entries.
3154 * If <b>include_ipv6</b> is true, include IPv6 entries.
3155 */
3156 char *
router_dump_exit_policy_to_string(const routerinfo_t * router,int include_ipv4,int include_ipv6)3157 router_dump_exit_policy_to_string(const routerinfo_t *router,
3158 int include_ipv4,
3159 int include_ipv6)
3160 {
3161 if ((!router->exit_policy) || (router->policy_is_reject_star)) {
3162 return tor_strdup("reject *:*");
3163 }
3164
3165 return policy_dump_to_string(router->exit_policy,
3166 include_ipv4,
3167 include_ipv6);
3168 }
3169
3170 /** Load the contents of <b>filename</b>, find a line starting with
3171 * timestamp tag <b>ts_tag</b>, ensure that its timestamp is not more than 25
3172 * hours in the past or more than 1 hour in the future with respect to
3173 * <b>now</b>, and write the entire file contents into <b>out</b>.
3174 *
3175 * The timestamp expected should be an ISO-formatted UTC time value which is
3176 * parsed using our parse_iso_time() function.
3177 *
3178 * In case more than one tag are found in the file, the very first one is
3179 * used.
3180 *
3181 * Return 1 for success, 0 if the file does not exist or is empty, or -1 if
3182 * the file does not contain a line with the timestamp tag. */
3183 STATIC int
load_stats_file(const char * filename,const char * ts_tag,time_t now,char ** out)3184 load_stats_file(const char *filename, const char *ts_tag, time_t now,
3185 char **out)
3186 {
3187 int r = -1;
3188 char *fname = get_datadir_fname(filename);
3189 char *contents = NULL, timestr[ISO_TIME_LEN+1];
3190 time_t written;
3191
3192 switch (file_status(fname)) {
3193 case FN_FILE:
3194 contents = read_file_to_str(fname, 0, NULL);
3195 if (contents == NULL) {
3196 log_debug(LD_BUG, "Unable to read content of %s", filename);
3197 goto end;
3198 }
3199 /* Find the timestamp tag to validate that the file is not too old or if
3200 * exists. */
3201 const char *ts_tok = find_str_at_start_of_line(contents, ts_tag);
3202 if (!ts_tok) {
3203 log_warn(LD_BUG, "Token %s not found in file %s", ts_tag, filename);
3204 goto end;
3205 }
3206 /* Do we have enough for parsing a timestamp? */
3207 if (strlen(ts_tok) < strlen(ts_tag) + 1 + sizeof(timestr)) {
3208 log_warn(LD_BUG, "Token %s malformed in file %s", ts_tag, filename);
3209 goto end;
3210 }
3211 /* Parse timestamp in order to validate it is not too old. */
3212 strlcpy(timestr, ts_tok + strlen(ts_tag) + 1, sizeof(timestr));
3213 if (parse_iso_time(timestr, &written) < 0) {
3214 log_warn(LD_BUG, "Token %s has a malformed timestamp in file %s",
3215 ts_tag, filename);
3216 goto end;
3217 }
3218 if (written < now - (25*60*60) || written > now + (1*60*60)) {
3219 /* This can happen normally so don't log. */
3220 goto end;
3221 }
3222 /* Success. Put in the entire content. */
3223 *out = contents;
3224 contents = NULL; /* Must not free it. */
3225 r = 1;
3226 break;
3227 /* treat empty stats files as if the file doesn't exist */
3228 case FN_NOENT:
3229 case FN_EMPTY:
3230 r = 0;
3231 break;
3232 case FN_ERROR:
3233 case FN_DIR:
3234 default:
3235 break;
3236 }
3237
3238 end:
3239 tor_free(fname);
3240 tor_free(contents);
3241 return r;
3242 }
3243
3244 /** Add header strings to chunks, based on the extrainfo object extrainfo,
3245 * and ed25519 keypair signing_keypair, if emit_ed_sigs is true.
3246 * Helper for extrainfo_dump_to_string().
3247 * Returns 0 on success, negative on failure. */
3248 static int
extrainfo_dump_to_string_header_helper(smartlist_t * chunks,const extrainfo_t * extrainfo,const ed25519_keypair_t * signing_keypair,int emit_ed_sigs)3249 extrainfo_dump_to_string_header_helper(
3250 smartlist_t *chunks,
3251 const extrainfo_t *extrainfo,
3252 const ed25519_keypair_t *signing_keypair,
3253 int emit_ed_sigs)
3254 {
3255 char identity[HEX_DIGEST_LEN+1];
3256 char published[ISO_TIME_LEN+1];
3257 char *ed_cert_line = NULL;
3258 char *pre = NULL;
3259 int rv = -1;
3260
3261 base16_encode(identity, sizeof(identity),
3262 extrainfo->cache_info.identity_digest, DIGEST_LEN);
3263 format_iso_time(published, extrainfo->cache_info.published_on);
3264 if (emit_ed_sigs) {
3265 if (!extrainfo->cache_info.signing_key_cert->signing_key_included ||
3266 !ed25519_pubkey_eq(&extrainfo->cache_info.signing_key_cert->signed_key,
3267 &signing_keypair->pubkey)) {
3268 log_warn(LD_BUG, "Tried to sign a extrainfo descriptor with a "
3269 "mismatched ed25519 key chain %d",
3270 extrainfo->cache_info.signing_key_cert->signing_key_included);
3271 goto err;
3272 }
3273 char ed_cert_base64[256];
3274 if (base64_encode(ed_cert_base64, sizeof(ed_cert_base64),
3275 (const char*)extrainfo->cache_info.signing_key_cert->encoded,
3276 extrainfo->cache_info.signing_key_cert->encoded_len,
3277 BASE64_ENCODE_MULTILINE) < 0) {
3278 log_err(LD_BUG,"Couldn't base64-encode signing key certificate!");
3279 goto err;
3280 }
3281 tor_asprintf(&ed_cert_line, "identity-ed25519\n"
3282 "-----BEGIN ED25519 CERT-----\n"
3283 "%s"
3284 "-----END ED25519 CERT-----\n", ed_cert_base64);
3285 } else {
3286 ed_cert_line = tor_strdup("");
3287 }
3288
3289 /* This is the first chunk in the file. If the file is too big, other chunks
3290 * are removed. So we must only add one chunk here. */
3291 tor_asprintf(&pre, "extra-info %s %s\n%spublished %s\n",
3292 extrainfo->nickname, identity,
3293 ed_cert_line,
3294 published);
3295 smartlist_add(chunks, pre);
3296
3297 rv = 0;
3298 goto done;
3299
3300 err:
3301 rv = -1;
3302
3303 done:
3304 tor_free(ed_cert_line);
3305 return rv;
3306 }
3307
3308 /** Add pluggable transport and statistics strings to chunks, skipping
3309 * statistics if write_stats_to_extrainfo is false.
3310 * Helper for extrainfo_dump_to_string().
3311 * Can not fail. */
3312 static void
extrainfo_dump_to_string_stats_helper(smartlist_t * chunks,int write_stats_to_extrainfo)3313 extrainfo_dump_to_string_stats_helper(smartlist_t *chunks,
3314 int write_stats_to_extrainfo)
3315 {
3316 const or_options_t *options = get_options();
3317 char *contents = NULL;
3318 time_t now = time(NULL);
3319
3320 /* If the file is too big, these chunks are removed, starting with the last
3321 * chunk. So each chunk must be a complete line, and the file must be valid
3322 * after each chunk. */
3323
3324 /* Add information about the pluggable transports we support, even if we
3325 * are not publishing statistics. This information is needed by BridgeDB
3326 * to distribute bridges. */
3327 if (options->ServerTransportPlugin) {
3328 char *pluggable_transports = pt_get_extra_info_descriptor_string();
3329 if (pluggable_transports)
3330 smartlist_add(chunks, pluggable_transports);
3331 }
3332
3333 if (options->ExtraInfoStatistics && write_stats_to_extrainfo) {
3334 log_info(LD_GENERAL, "Adding stats to extra-info descriptor.");
3335 /* Bandwidth usage stats don't have their own option */
3336 {
3337 contents = bwhist_get_bandwidth_lines();
3338 smartlist_add(chunks, contents);
3339 }
3340 /* geoip hashes aren't useful unless we are publishing other stats */
3341 if (geoip_is_loaded(AF_INET))
3342 smartlist_add_asprintf(chunks, "geoip-db-digest %s\n",
3343 geoip_db_digest(AF_INET));
3344 if (geoip_is_loaded(AF_INET6))
3345 smartlist_add_asprintf(chunks, "geoip6-db-digest %s\n",
3346 geoip_db_digest(AF_INET6));
3347 if (options->DirReqStatistics &&
3348 load_stats_file("stats"PATH_SEPARATOR"dirreq-stats",
3349 "dirreq-stats-end", now, &contents) > 0) {
3350 smartlist_add(chunks, contents);
3351 }
3352 if (options->HiddenServiceStatistics &&
3353 load_stats_file("stats"PATH_SEPARATOR"hidserv-stats",
3354 "hidserv-stats-end", now, &contents) > 0) {
3355 smartlist_add(chunks, contents);
3356 }
3357 if (options->HiddenServiceStatistics &&
3358 load_stats_file("stats"PATH_SEPARATOR"hidserv-v3-stats",
3359 "hidserv-v3-stats-end", now, &contents) > 0) {
3360 smartlist_add(chunks, contents);
3361 }
3362 if (options->EntryStatistics &&
3363 load_stats_file("stats"PATH_SEPARATOR"entry-stats",
3364 "entry-stats-end", now, &contents) > 0) {
3365 smartlist_add(chunks, contents);
3366 }
3367 if (options->CellStatistics &&
3368 load_stats_file("stats"PATH_SEPARATOR"buffer-stats",
3369 "cell-stats-end", now, &contents) > 0) {
3370 smartlist_add(chunks, contents);
3371 }
3372 if (options->ExitPortStatistics &&
3373 load_stats_file("stats"PATH_SEPARATOR"exit-stats",
3374 "exit-stats-end", now, &contents) > 0) {
3375 smartlist_add(chunks, contents);
3376 }
3377 if (options->ConnDirectionStatistics &&
3378 load_stats_file("stats"PATH_SEPARATOR"conn-stats",
3379 "conn-bi-direct", now, &contents) > 0) {
3380 smartlist_add(chunks, contents);
3381 }
3382 if (options->PaddingStatistics) {
3383 contents = rep_hist_get_padding_count_lines();
3384 if (contents)
3385 smartlist_add(chunks, contents);
3386 }
3387 if (options->OverloadStatistics) {
3388 contents = rep_hist_get_overload_stats_lines();
3389 if (contents) {
3390 smartlist_add(chunks, contents);
3391 }
3392 }
3393 /* bridge statistics */
3394 if (should_record_bridge_info(options)) {
3395 const char *bridge_stats = geoip_get_bridge_stats_extrainfo(now);
3396 if (bridge_stats) {
3397 smartlist_add_strdup(chunks, bridge_stats);
3398 }
3399 }
3400 }
3401 }
3402
3403 /** Add an ed25519 signature of chunks to chunks, using the ed25519 keypair
3404 * signing_keypair.
3405 * Helper for extrainfo_dump_to_string().
3406 * Returns 0 on success, negative on failure. */
3407 static int
extrainfo_dump_to_string_ed_sig_helper(smartlist_t * chunks,const ed25519_keypair_t * signing_keypair)3408 extrainfo_dump_to_string_ed_sig_helper(
3409 smartlist_t *chunks,
3410 const ed25519_keypair_t *signing_keypair)
3411 {
3412 char sha256_digest[DIGEST256_LEN];
3413 ed25519_signature_t ed_sig;
3414 char buf[ED25519_SIG_BASE64_LEN+1];
3415 int rv = -1;
3416
3417 /* These are two of the three final chunks in the file. If the file is too
3418 * big, other chunks are removed. So we must only add two chunks here. */
3419 smartlist_add_strdup(chunks, "router-sig-ed25519 ");
3420 crypto_digest_smartlist_prefix(sha256_digest, DIGEST256_LEN,
3421 ED_DESC_SIGNATURE_PREFIX,
3422 chunks, "", DIGEST_SHA256);
3423 if (ed25519_sign(&ed_sig, (const uint8_t*)sha256_digest, DIGEST256_LEN,
3424 signing_keypair) < 0)
3425 goto err;
3426 ed25519_signature_to_base64(buf, &ed_sig);
3427
3428 smartlist_add_asprintf(chunks, "%s\n", buf);
3429
3430 rv = 0;
3431 goto done;
3432
3433 err:
3434 rv = -1;
3435
3436 done:
3437 return rv;
3438 }
3439
3440 /** Add an RSA signature of extrainfo_string to chunks, using the RSA key
3441 * ident_key.
3442 * Helper for extrainfo_dump_to_string().
3443 * Returns 0 on success, negative on failure. */
3444 static int
extrainfo_dump_to_string_rsa_sig_helper(smartlist_t * chunks,crypto_pk_t * ident_key,const char * extrainfo_string)3445 extrainfo_dump_to_string_rsa_sig_helper(smartlist_t *chunks,
3446 crypto_pk_t *ident_key,
3447 const char *extrainfo_string)
3448 {
3449 char sig[DIROBJ_MAX_SIG_LEN+1];
3450 char digest[DIGEST_LEN];
3451 int rv = -1;
3452
3453 memset(sig, 0, sizeof(sig));
3454 if (router_get_extrainfo_hash(extrainfo_string, strlen(extrainfo_string),
3455 digest) < 0 ||
3456 router_append_dirobj_signature(sig, sizeof(sig), digest, DIGEST_LEN,
3457 ident_key) < 0) {
3458 log_warn(LD_BUG, "Could not append signature to extra-info "
3459 "descriptor.");
3460 goto err;
3461 }
3462 smartlist_add_strdup(chunks, sig);
3463
3464 rv = 0;
3465 goto done;
3466
3467 err:
3468 rv = -1;
3469
3470 done:
3471 return rv;
3472 }
3473
3474 /** Write the contents of <b>extrainfo</b>, to * *<b>s_out</b>, signing them
3475 * with <b>ident_key</b>.
3476 *
3477 * If ExtraInfoStatistics is 1, also write aggregated statistics and related
3478 * configuration data before signing. Most statistics also have an option that
3479 * enables or disables that particular statistic.
3480 *
3481 * Always write pluggable transport lines.
3482 *
3483 * Return 0 on success, negative on failure. */
3484 int
extrainfo_dump_to_string(char ** s_out,extrainfo_t * extrainfo,crypto_pk_t * ident_key,const ed25519_keypair_t * signing_keypair)3485 extrainfo_dump_to_string(char **s_out, extrainfo_t *extrainfo,
3486 crypto_pk_t *ident_key,
3487 const ed25519_keypair_t *signing_keypair)
3488 {
3489 int result;
3490 static int write_stats_to_extrainfo = 1;
3491 char *s = NULL, *cp, *s_dup = NULL;
3492 smartlist_t *chunks = smartlist_new();
3493 extrainfo_t *ei_tmp = NULL;
3494 const int emit_ed_sigs = signing_keypair &&
3495 extrainfo->cache_info.signing_key_cert;
3496 int rv = 0;
3497
3498 rv = extrainfo_dump_to_string_header_helper(chunks, extrainfo,
3499 signing_keypair,
3500 emit_ed_sigs);
3501 if (rv < 0)
3502 goto err;
3503
3504 extrainfo_dump_to_string_stats_helper(chunks, write_stats_to_extrainfo);
3505
3506 if (emit_ed_sigs) {
3507 rv = extrainfo_dump_to_string_ed_sig_helper(chunks, signing_keypair);
3508 if (rv < 0)
3509 goto err;
3510 }
3511
3512 /* This is one of the three final chunks in the file. If the file is too big,
3513 * other chunks are removed. So we must only add one chunk here. */
3514 smartlist_add_strdup(chunks, "router-signature\n");
3515 s = smartlist_join_strings(chunks, "", 0, NULL);
3516
3517 while (strlen(s) > MAX_EXTRAINFO_UPLOAD_SIZE - DIROBJ_MAX_SIG_LEN) {
3518 /* So long as there are at least two chunks (one for the initial
3519 * extra-info line and one for the router-signature), we can keep removing
3520 * things. If emit_ed_sigs is true, we also keep 2 additional chunks at the
3521 * end for the ed25519 signature. */
3522 const int required_chunks = emit_ed_sigs ? 4 : 2;
3523 if (smartlist_len(chunks) > required_chunks) {
3524 /* We remove the next-to-last or 4th-last element (remember, len-1 is the
3525 * last element), since we need to keep the router-signature elements. */
3526 int idx = smartlist_len(chunks) - required_chunks;
3527 char *e = smartlist_get(chunks, idx);
3528 smartlist_del_keeporder(chunks, idx);
3529 log_warn(LD_GENERAL, "We just generated an extra-info descriptor "
3530 "with statistics that exceeds the 50 KB "
3531 "upload limit. Removing last added "
3532 "statistics.");
3533 tor_free(e);
3534 tor_free(s);
3535 s = smartlist_join_strings(chunks, "", 0, NULL);
3536 } else {
3537 log_warn(LD_BUG, "We just generated an extra-info descriptors that "
3538 "exceeds the 50 KB upload limit.");
3539 goto err;
3540 }
3541 }
3542
3543 rv = extrainfo_dump_to_string_rsa_sig_helper(chunks, ident_key, s);
3544 if (rv < 0)
3545 goto err;
3546
3547 tor_free(s);
3548 s = smartlist_join_strings(chunks, "", 0, NULL);
3549
3550 cp = s_dup = tor_strdup(s);
3551 ei_tmp = extrainfo_parse_entry_from_string(cp, NULL, 1, NULL, NULL);
3552 if (!ei_tmp) {
3553 if (write_stats_to_extrainfo) {
3554 log_warn(LD_GENERAL, "We just generated an extra-info descriptor "
3555 "with statistics that we can't parse. Not "
3556 "adding statistics to this or any future "
3557 "extra-info descriptors.");
3558 write_stats_to_extrainfo = 0;
3559 result = extrainfo_dump_to_string(s_out, extrainfo, ident_key,
3560 signing_keypair);
3561 goto done;
3562 } else {
3563 log_warn(LD_BUG, "We just generated an extrainfo descriptor we "
3564 "can't parse.");
3565 goto err;
3566 }
3567 }
3568
3569 *s_out = s;
3570 s = NULL; /* prevent free */
3571 result = 0;
3572 goto done;
3573
3574 err:
3575 result = -1;
3576
3577 done:
3578 tor_free(s);
3579 SMARTLIST_FOREACH(chunks, char *, chunk, tor_free(chunk));
3580 smartlist_free(chunks);
3581 tor_free(s_dup);
3582 extrainfo_free(ei_tmp);
3583
3584 return result;
3585 }
3586
3587 /** Forget that we have issued any router-related warnings, so that we'll
3588 * warn again if we see the same errors. */
3589 void
router_reset_warnings(void)3590 router_reset_warnings(void)
3591 {
3592 if (warned_family) {
3593 SMARTLIST_FOREACH(warned_family, char *, cp, tor_free(cp));
3594 smartlist_clear(warned_family);
3595 }
3596 }
3597
3598 /** Release all static resources held in router.c */
3599 void
router_free_all(void)3600 router_free_all(void)
3601 {
3602 crypto_pk_free(onionkey);
3603 crypto_pk_free(lastonionkey);
3604 crypto_pk_free(server_identitykey);
3605 crypto_pk_free(client_identitykey);
3606
3607 /* Destroying a locked mutex is undefined behaviour. This mutex may be
3608 * locked, because multiple threads can access it. But we need to destroy
3609 * it, otherwise re-initialisation will trigger undefined behaviour.
3610 * See #31735 for details. */
3611 tor_mutex_free(key_lock);
3612 routerinfo_free(desc_routerinfo);
3613 extrainfo_free(desc_extrainfo);
3614 crypto_pk_free(authority_signing_key);
3615 authority_cert_free(authority_key_certificate);
3616 crypto_pk_free(legacy_signing_key);
3617 authority_cert_free(legacy_key_certificate);
3618
3619 memwipe(&curve25519_onion_key, 0, sizeof(curve25519_onion_key));
3620 memwipe(&last_curve25519_onion_key, 0, sizeof(last_curve25519_onion_key));
3621
3622 if (warned_family) {
3623 SMARTLIST_FOREACH(warned_family, char *, cp, tor_free(cp));
3624 smartlist_free(warned_family);
3625 }
3626 }
3627
3628 /* From the given RSA key object, convert it to ASN-1 encoded format and set
3629 * the newly allocated object in onion_pkey_out. The length of the key is set
3630 * in onion_pkey_len_out. */
3631 void
router_set_rsa_onion_pkey(const crypto_pk_t * pk,char ** onion_pkey_out,size_t * onion_pkey_len_out)3632 router_set_rsa_onion_pkey(const crypto_pk_t *pk, char **onion_pkey_out,
3633 size_t *onion_pkey_len_out)
3634 {
3635 int len;
3636 char buf[1024];
3637
3638 tor_assert(pk);
3639 tor_assert(onion_pkey_out);
3640 tor_assert(onion_pkey_len_out);
3641
3642 len = crypto_pk_asn1_encode(pk, buf, sizeof(buf));
3643 if (BUG(len < 0)) {
3644 goto done;
3645 }
3646
3647 *onion_pkey_out = tor_memdup(buf, len);
3648 *onion_pkey_len_out = len;
3649
3650 done:
3651 return;
3652 }
3653
3654 /* From an ASN-1 encoded onion pkey, return a newly allocated RSA key object.
3655 * It is the caller's responsibility to free the returned object.
3656 *
3657 * Return NULL if the pkey is NULL, malformed or if the length is 0. */
3658 crypto_pk_t *
router_get_rsa_onion_pkey(const char * pkey,size_t pkey_len)3659 router_get_rsa_onion_pkey(const char *pkey, size_t pkey_len)
3660 {
3661 if (!pkey || pkey_len == 0) {
3662 return NULL;
3663 }
3664 return crypto_pk_asn1_decode(pkey, pkey_len);
3665 }
3666