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