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