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