src/or/router.c

   1 /* Copyright 2001 Matej Pfajfar.
   2  * Copyright 2001-2004 Roger Dingledine.
   3  * Copyright 2004-2005 Roger Dingledine, Nick Mathewson. */
   4 /* See LICENSE for licensing information */
   5 /* $Id$ */
   6 const char router_c_id[] = "$Id$";
   7
   8 #include "or.h"
   9
  10 /**
  11  * \file router.c
  12  * \brief OR functionality, including key maintenance, generating
  13  * and uploading server descriptors, retrying OR connections.
  14  **/
  15
  16 extern long stats_n_seconds_working;
  17
  18 /** Exposed for test.c. */ void get_platform_str(char *platform, size_t len);
  19
  20 /************************************************************/
  21
  22 /*****
  23  * Key management: ORs only.
  24  *****/
  25
  26 /** Private keys for this OR.  There is also an SSL key managed by tortls.c.
  27  */
  28 static tor_mutex_t *key_lock=NULL;
  29 static time_t onionkey_set_at=0; /* When was onionkey last changed? */
  30 static crypto_pk_env_t *onionkey=NULL;
  31 static crypto_pk_env_t *lastonionkey=NULL;
  32 static crypto_pk_env_t *identitykey=NULL;
  33
  34 /** Replace the current onion key with <b>k</b>.  Does not affect lastonionkey;
  35  * to update onionkey correctly, call rotate_onion_key().
  36  */
  37 void set_onion_key(crypto_pk_env_t *k) {
  38   tor_mutex_acquire(key_lock);
  39   onionkey = k;
  40   onionkey_set_at = time(NULL);
  41   tor_mutex_release(key_lock);
  42   mark_my_descriptor_dirty();
  43 }
  44
  45 /** Return the current onion key.  Requires that the onion key has been
  46  * loaded or generated. */
  47 crypto_pk_env_t *get_onion_key(void) {
  48   tor_assert(onionkey);
  49   return onionkey;
  50 }
  51
  52 /** Return the onion key that was current before the most recent onion
  53  * key rotation.  If no rotation has been performed since this process
  54  * started, return NULL.
  55  */
  56 crypto_pk_env_t *get_previous_onion_key(void) {
  57   return lastonionkey;
  58 }
  59
  60 /** Store a copy of the current onion key into *<b>key</b>, and a copy
  61  * of the most recent onion key into *<b>last</b>.
  62  */
  63 void dup_onion_keys(crypto_pk_env_t **key, crypto_pk_env_t **last)
  64 {
  65   tor_assert(key);
  66   tor_assert(last);
  67   tor_mutex_acquire(key_lock);
  68   *key = crypto_pk_dup_key(onionkey);
  69   if (lastonionkey)
  70     *last = crypto_pk_dup_key(lastonionkey);
  71   else
  72     *last = NULL;
  73   tor_mutex_release(key_lock);
  74 }
  75
  76 /** Return the time when the onion key was last set.  This is either the time
  77  * when the process launched, or the time of the most recent key rotation since
  78  * the process launched.
  79  */
  80 time_t get_onion_key_set_at(void) {
  81   return onionkey_set_at;
  82 }
  83
  84 /** Set the current identity key to k.
  85  */
  86 void set_identity_key(crypto_pk_env_t *k) {
  87   identitykey = k;
  88 }
  89
  90 /** Returns the current identity key; requires that the identity key has been
  91  * set.
  92  */
  93 crypto_pk_env_t *get_identity_key(void) {
  94   tor_assert(identitykey);
  95   return identitykey;
  96 }
  97
  98 /** Return true iff the identity key has been set. */
  99 int identity_key_is_set(void) {
 100   return identitykey != NULL;
 101 }
 102
 103 /** Replace the previous onion key with the current onion key, and generate
 104  * a new previous onion key.  Immediately after calling this function,
 105  * the OR should:
 106  *   - schedule all previous cpuworkers to shut down _after_ processing
 107  *     pending work.  (This will cause fresh cpuworkers to be generated.)
 108  *   - generate and upload a fresh routerinfo.
 109  */
 110 void rotate_onion_key(void)
 111 {
 112   char fname[512];
 113   char fname_prev[512];
 114   crypto_pk_env_t *prkey;
 115   tor_snprintf(fname,sizeof(fname),
 116            "%s/keys/secret_onion_key",get_options()->DataDirectory);
 117   tor_snprintf(fname_prev,sizeof(fname_prev),
 118            "%s/keys/secret_onion_key.old",get_options()->DataDirectory);
 119   if (!(prkey = crypto_new_pk_env())) {
 120     log(LOG_ERR, "Error creating crypto environment.");
 121     goto error;
 122   }
 123   if (crypto_pk_generate_key(prkey)) {
 124     log(LOG_ERR, "Error generating onion key");
 125     goto error;
 126   }
 127   if (file_status(fname) == FN_FILE) {
 128     if (replace_file(fname, fname_prev))
 129       goto error;
 130   }
 131   if (crypto_pk_write_private_key_to_filename(prkey, fname)) {
 132     log(LOG_ERR, "Couldn't write generated key to %s.", fname);
 133     goto error;
 134   }
 135   log_fn(LOG_INFO, "Rotating onion key");
 136   tor_mutex_acquire(key_lock);
 137   if (lastonionkey)
 138     crypto_free_pk_env(lastonionkey);
 139   lastonionkey = onionkey;
 140   onionkey = prkey;
 141   onionkey_set_at = time(NULL);
 142   tor_mutex_release(key_lock);
 143   mark_my_descriptor_dirty();
 144   return;
 145  error:
 146   log_fn(LOG_WARN, "Couldn't rotate onion key.");
 147 }
 148
 149 /* Read an RSA secret key key from a file that was once named fname_old,
 150  * but is now named fname_new.  Rename the file from old to new as needed.
 151  */
 152 static crypto_pk_env_t *
 153 init_key_from_file_name_changed(const char *fname_old,
 154                                 const char *fname_new)
 155 {
 156
 157   if (file_status(fname_new) == FN_FILE || file_status(fname_old) != FN_FILE)
 158     /* The new filename is there, or both are, or neither is. */
 159     return init_key_from_file(fname_new);
 160
 161   /* The old filename exists, and the new one doesn't.  Rename and load. */
 162   if (rename(fname_old, fname_new) < 0) {
 163     log_fn(LOG_ERR, "Couldn't rename %s to %s: %s", fname_old, fname_new,
 164            strerror(errno));
 165     return NULL;
 166   }
 167   return init_key_from_file(fname_new);
 168 }
 169
 170 /** Try to read an RSA key from <b>fname</b>.  If <b>fname</b> doesn't exist,
 171  * create a new RSA key and save it in <b>fname</b>.  Return the read/created
 172  * key, or NULL on error.
 173  */
 174 crypto_pk_env_t *init_key_from_file(const char *fname)
 175 {
 176   crypto_pk_env_t *prkey = NULL;
 177   FILE *file = NULL;
 178
 179   if (!(prkey = crypto_new_pk_env())) {
 180     log(LOG_ERR, "Error creating crypto environment.");
 181     goto error;
 182   }
 183
 184   switch (file_status(fname)) {
 185     case FN_DIR:
 186     case FN_ERROR:
 187       log(LOG_ERR, "Can't read key from %s", fname);
 188       goto error;
 189     case FN_NOENT:
 190       log(LOG_INFO, "No key found in %s; generating fresh key.", fname);
 191       if (crypto_pk_generate_key(prkey)) {
 192         log(LOG_ERR, "Error generating onion key");
 193         goto error;
 194       }
 195       if (crypto_pk_check_key(prkey) <= 0) {
 196         log(LOG_ERR, "Generated key seems invalid");
 197         goto error;
 198       }
 199       log(LOG_INFO, "Generated key seems valid");
 200       if (crypto_pk_write_private_key_to_filename(prkey, fname)) {
 201         log(LOG_ERR, "Couldn't write generated key to %s.", fname);
 202         goto error;
 203       }
 204       return prkey;
 205     case FN_FILE:
 206       if (crypto_pk_read_private_key_from_filename(prkey, fname)) {
 207         log(LOG_ERR, "Error loading private key.");
 208         goto error;
 209       }
 210       return prkey;
 211     default:
 212       tor_assert(0);
 213   }
 214
 215  error:
 216   if (prkey)
 217     crypto_free_pk_env(prkey);
 218   if (file)
 219     fclose(file);
 220   return NULL;
 221 }
 222
 223 /** Initialize all OR private keys, and the TLS context, as necessary.
 224  * On OPs, this only initializes the tls context.
 225  */
 226 int init_keys(void) {
 227   /* XXX009 Two problems with how this is called:
 228    * 1. It should be idempotent for servers, so we can call init_keys
 229    *    as much as we need to.
 230    * 2. Clients should rotate their identity keys at least whenever
 231    *    their IPs change.
 232    */
 233   char keydir[512];
 234   char keydir2[512];
 235   char fingerprint[FINGERPRINT_LEN+1];
 236   char fingerprint_line[FINGERPRINT_LEN+MAX_NICKNAME_LEN+3];/*nickname fp\n\0 */
 237   char *cp;
 238   const char *tmp, *mydesc, *datadir;
 239   crypto_pk_env_t *prkey;
 240   char digest[20];
 241   or_options_t *options = get_options();
 242
 243   if (!key_lock)
 244     key_lock = tor_mutex_new();
 245
 246   /* OP's don't need persistent keys; just make up an identity and
 247    * initialize the TLS context. */
 248   if (!server_mode(options)) {
 249     if (!(prkey = crypto_new_pk_env()))
 250       return -1;
 251     if (crypto_pk_generate_key(prkey))
 252       return -1;
 253     set_identity_key(prkey);
 254     /* Create a TLS context; default the client nickname to "client". */
 255     if (tor_tls_context_new(get_identity_key(), 1,
 256                             options->Nickname ? options->Nickname : "client",
 257                             MAX_SSL_KEY_LIFETIME) < 0) {
 258       log_fn(LOG_ERR, "Error creating TLS context for OP.");
 259       return -1;
 260     }
 261     return 0;
 262   }
 263   /* Make sure DataDirectory exists, and is private. */
 264   datadir = options->DataDirectory;
 265   if (check_private_dir(datadir, CPD_CREATE)) {
 266     return -1;
 267   }
 268   /* Check the key directory. */
 269   tor_snprintf(keydir,sizeof(keydir),"%s/keys", datadir);
 270   if (check_private_dir(keydir, CPD_CREATE)) {
 271     return -1;
 272   }
 273   cp = keydir + strlen(keydir); /* End of string. */
 274
 275   /* 1. Read identity key. Make it if none is found. */
 276   tor_snprintf(keydir,sizeof(keydir),"%s/keys/identity.key",datadir);
 277   tor_snprintf(keydir2,sizeof(keydir2),"%s/keys/secret_id_key",datadir);
 278   log_fn(LOG_INFO,"Reading/making identity key %s...",keydir2);
 279   prkey = init_key_from_file_name_changed(keydir,keydir2);
 280   if (!prkey) return -1;
 281   set_identity_key(prkey);
 282   /* 2. Read onion key.  Make it if none is found. */
 283   tor_snprintf(keydir,sizeof(keydir),"%s/keys/onion.key",datadir);
 284   tor_snprintf(keydir2,sizeof(keydir2),"%s/keys/secret_onion_key",datadir);
 285   log_fn(LOG_INFO,"Reading/making onion key %s...",keydir2);
 286   prkey = init_key_from_file_name_changed(keydir,keydir2);
 287   if (!prkey) return -1;
 288   set_onion_key(prkey);
 289   tor_snprintf(keydir,sizeof(keydir),"%s/keys/secret_onion_key.old",datadir);
 290   if (file_status(keydir) == FN_FILE) {
 291     prkey = init_key_from_file(keydir);
 292     if (prkey)
 293       lastonionkey = prkey;
 294   }
 295
 296   /* 3. Initialize link key and TLS context. */
 297   if (tor_tls_context_new(get_identity_key(), 1, options->Nickname,
 298                           MAX_SSL_KEY_LIFETIME) < 0) {
 299     log_fn(LOG_ERR, "Error initializing TLS context");
 300     return -1;
 301   }
 302   /* 4. Dump router descriptor to 'router.desc' */
 303   /* Must be called after keys are initialized. */
 304   tmp = mydesc = router_get_my_descriptor();
 305   if (!mydesc) {
 306     log_fn(LOG_ERR, "Error initializing descriptor.");
 307     return -1;
 308   }
 309   if (authdir_mode(options)) {
 310     const char *m;
 311     /* We need to add our own fingerprint so it gets recognized. */
 312     if (dirserv_add_own_fingerprint(options->Nickname, get_identity_key())) {
 313       log_fn(LOG_ERR, "Error adding own fingerprint to approved set");
 314       return -1;
 315     }
 316     if (dirserv_add_descriptor(&tmp, &m) != 1) {
 317       log(LOG_ERR, "Unable to add own descriptor to directory: %s",
 318           m?m:"<unknown error>");
 319       return -1;
 320     }
 321   }
 322
 323   tor_snprintf(keydir,sizeof(keydir),"%s/router.desc", datadir);
 324   log_fn(LOG_INFO,"Dumping descriptor to %s...",keydir);
 325   if (write_str_to_file(keydir, mydesc,0)) {
 326     return -1;
 327   }
 328   /* 5. Dump fingerprint to 'fingerprint' */
 329   tor_snprintf(keydir,sizeof(keydir),"%s/fingerprint", datadir);
 330   log_fn(LOG_INFO,"Dumping fingerprint to %s...",keydir);
 331   if (crypto_pk_get_fingerprint(get_identity_key(), fingerprint, 1)<0) {
 332     log_fn(LOG_ERR, "Error computing fingerprint");
 333     return -1;
 334   }
 335   tor_assert(strlen(options->Nickname) <= MAX_NICKNAME_LEN);
 336   if (tor_snprintf(fingerprint_line, sizeof(fingerprint_line),
 337                    "%s %s\n",options->Nickname, fingerprint) < 0) {
 338     log_fn(LOG_ERR, "Error writing fingerprint line");
 339     return -1;
 340   }
 341   if (write_str_to_file(keydir, fingerprint_line, 0))
 342     return -1;
 343   if (!authdir_mode(options))
 344     return 0;
 345   /* 6. [authdirserver only] load approved-routers file */
 346   tor_snprintf(keydir,sizeof(keydir),"%s/approved-routers", datadir);
 347   log_fn(LOG_INFO,"Loading approved fingerprints from %s...",keydir);
 348   if (dirserv_parse_fingerprint_file(keydir) < 0) {
 349     log_fn(LOG_ERR, "Error loading fingerprints");
 350     return -1;
 351   }
 352   /* 6b. [authdirserver only] add own key to approved directories. */
 353   crypto_pk_get_digest(get_identity_key(), digest);
 354   if (!router_digest_is_trusted_dir(digest)) {
 355     add_trusted_dir_server(options->Address, (uint16_t)options->DirPort, digest);
 356   }
 357   /* 7. [authdirserver only] load old directory, if it's there */
 358   tor_snprintf(keydir,sizeof(keydir),"%s/cached-directory", datadir);
 359   log_fn(LOG_INFO,"Loading cached directory from %s...",keydir);
 360   cp = read_file_to_str(keydir,0);
 361   if (!cp) {
 362     log_fn(LOG_INFO,"Cached directory %s not present. Ok.",keydir);
 363   } else {
 364     if (dirserv_load_from_directory_string(cp) < 0) {
 365       log_fn(LOG_WARN, "Cached directory %s is corrupt, only loaded part of it.", keydir);
 366       tor_free(cp);
 367       return 0;
 368     }
 369     tor_free(cp);
 370   }
 371   /* success */
 372   return 0;
 373 }
 374
 375 /* Keep track of whether we should upload our server descriptor,
 376  * and what type of server we are.
 377  */
 378
 379 /** Whether we can reach our ORPort from the outside. */
 380 static int can_reach_or_port = 0;
 381 /** Whether we can reach our DirPort from the outside. */
 382 static int can_reach_dir_port = 0;
 383
 384 /** Return 1 if or port is known reachable; else return 0. */
 385 int check_whether_orport_reachable(void) {
 386   return clique_mode(get_options()) || can_reach_or_port;
 387 }
 388 /** Return 1 if we don't have a dirport configured, or if it's reachable. */
 389 int check_whether_dirport_reachable(void) {
 390   return !get_options()->DirPort || can_reach_dir_port;
 391 }
 392
 393 void consider_testing_reachability(void) {
 394   routerinfo_t *me = router_get_my_routerinfo();
 395   if (!me) {
 396     log_fn(LOG_WARN,"Bug: router_get_my_routerinfo() did not find my routerinfo?");
 397     return;
 398   }
 399
 400   if (!check_whether_orport_reachable()) {
 401     circuit_launch_by_router(CIRCUIT_PURPOSE_TESTING, me, 0, 1, 1);
 402   }
 403
 404   if (!check_whether_dirport_reachable()) {
 405     if (me) {
 406       directory_initiate_command_router(me, DIR_PURPOSE_FETCH_DIR, 1, NULL, NULL, 0);
 407     } else {
 408       log_fn(LOG_NOTICE,"Delaying checking DirPort reachability; can't build descriptor.");
 409     }
 410   }
 411 }
 412
 413 /** Annotate that we found our ORPort reachable. */
 414 void router_orport_found_reachable(void) {
 415   if (!can_reach_or_port) {
 416     if (!clique_mode(get_options()))
 417       log_fn(LOG_NOTICE,"Your ORPort is reachable from the outside. Excellent. Publishing server descriptor.");
 418     can_reach_or_port = 1;
 419     consider_publishable_server(time(NULL), 1);
 420   }
 421 }
 422
 423 /** Annotate that we found our DirPort reachable. */
 424 void router_dirport_found_reachable(void) {
 425   if (!can_reach_dir_port) {
 426     log_fn(LOG_NOTICE,"Your DirPort is reachable from the outside. Excellent.");
 427     can_reach_dir_port = 1;
 428   }
 429 }
 430
 431 /** Our router has just moved to a new IP. Reset stats. */
 432 void server_has_changed_ip(void) {
 433   stats_n_seconds_working = 0;
 434   can_reach_or_port = 0;
 435   can_reach_dir_port = 0;
 436   mark_my_descriptor_dirty();
 437 }
 438
 439 /** Return true iff we believe ourselves to be an authoritative
 440  * directory server.
 441  */
 442 int authdir_mode(or_options_t *options) {
 443   return options->AuthoritativeDir != 0;
 444 }
 445 /** Return true iff we try to stay connected to all ORs at once.
 446  */
 447 int clique_mode(or_options_t *options) {
 448   return authdir_mode(options);
 449 }
 450
 451 /** Return true iff we are trying to be a server.
 452  */
 453 int server_mode(or_options_t *options) {
 454   return (options->ORPort != 0 || options->ORBindAddress);
 455 }
 456
 457 /** Remember if we've advertised ourselves to the dirservers. */
 458 static int server_is_advertised=0;
 459
 460 /** Return true iff we have published our descriptor lately.
 461  */
 462 int advertised_server_mode(void) {
 463   return server_is_advertised;
 464 }
 465
 466 static void set_server_advertised(int s) {
 467   server_is_advertised = s;
 468 }
 469
 470 /** Return true iff we are trying to be a socks proxy. */
 471 int proxy_mode(or_options_t *options) {
 472   return (options->SocksPort != 0 || options->SocksBindAddress);
 473 }
 474
 475 /** Decide if we're a publishable server or just a client. We are a server if:
 476  * - We have the AuthoritativeDirectory option set.
 477  * or
 478  * - We don't have the ClientOnly option set; and
 479  * - We have ORPort set; and
 480  * - We believe we are reachable from the outside.
 481  */
 482 static int decide_if_publishable_server(time_t now) {
 483   or_options_t *options = get_options();
 484
 485   if (options->ClientOnly)
 486     return 0;
 487   if (!server_mode(options))
 488     return 0;
 489   if (options->AuthoritativeDir)
 490     return 1;
 491
 492   return check_whether_orport_reachable();
 493 }
 494
 495 void consider_publishable_server(time_t now, int force) {
 496   if (decide_if_publishable_server(now)) {
 497     set_server_advertised(1);
 498     router_rebuild_descriptor(force);
 499     router_upload_dir_desc_to_dirservers(force);
 500   } else {
 501     set_server_advertised(0);
 502   }
 503 }
 504
 505 /*
 506  * Clique maintenance
 507  */
 508
 509 /** OR only: if in clique mode, try to open connections to all of the
 510  * other ORs we know about. Otherwise, open connections to those we
 511  * think are in clique mode.
 512  */
 513 void router_retry_connections(void) {
 514   int i;
 515   routerinfo_t *router;
 516   routerlist_t *rl;
 517   or_options_t *options = get_options();
 518
 519   tor_assert(server_mode(options));
 520
 521   router_get_routerlist(&rl);
 522   if (!rl) return;
 523   for (i=0;i < smartlist_len(rl->routers);i++) {
 524     router = smartlist_get(rl->routers, i);
 525     if (router_is_me(router))
 526       continue;
 527     if (!clique_mode(options) && !router_is_clique_mode(router))
 528       continue;
 529     if (!connection_get_by_identity_digest(router->identity_digest,
 530                                            CONN_TYPE_OR)) {
 531       /* not in the list */
 532       log_fn(LOG_DEBUG,"connecting to OR at %s:%u.",router->address,router->or_port);
 533       connection_or_connect(router->addr, router->or_port, router->identity_digest);
 534     }
 535   }
 536 }
 537
 538 /** Return true iff this OR should try to keep connections open to all
 539  * other ORs. */
 540 int router_is_clique_mode(routerinfo_t *router) {
 541   if (router_digest_is_trusted_dir(router->identity_digest))
 542     return 1;
 543   return 0;
 544 }
 545
 546 /*
 547  * OR descriptor generation.
 548  */
 549
 550 /** My routerinfo. */
 551 static routerinfo_t *desc_routerinfo = NULL;
 552 /** Boolean: do we need to regenerate the above? */
 553 static int desc_is_dirty = 1;
 554 /** Boolean: do we need to regenerate the above? */
 555 static int desc_needs_upload = 0;
 556
 557 /** OR only: If <b>force</b> is true, or we haven't uploaded this
 558  * descriptor successfully yet, try to upload our signed descriptor to
 559  * all the directory servers we know about.
 560  */
 561 void router_upload_dir_desc_to_dirservers(int force) {
 562   const char *s;
 563
 564   s = router_get_my_descriptor();
 565   if (!s) {
 566     log_fn(LOG_WARN, "No descriptor; skipping upload");
 567     return;
 568   }
 569   if (!force || !desc_needs_upload)
 570     return;
 571   desc_needs_upload = 0;
 572   directory_post_to_dirservers(DIR_PURPOSE_UPLOAD_DIR, s, strlen(s));
 573 }
 574
 575 #define DEFAULT_EXIT_POLICY "reject 0.0.0.0/8,reject 169.254.0.0/16,reject 127.0.0.0/8,reject 192.168.0.0/16,reject 10.0.0.0/8,reject 172.16.0.0/12,reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*"
 576
 577 /** Set the exit policy on <b>router</b> to match the exit policy in the
 578  * current configuration file.  If the exit policy doesn't have a catch-all
 579  * rule, then append the default exit policy as well.
 580  */
 581 static void router_add_exit_policy_from_config(routerinfo_t *router) {
 582   addr_policy_t *ep;
 583   struct config_line_t default_policy;
 584   config_parse_addr_policy(get_options()->ExitPolicy, &router->exit_policy);
 585
 586   for (ep = router->exit_policy; ep; ep = ep->next) {
 587     if (ep->msk == 0 && ep->prt_min <= 1 && ep->prt_max >= 65535) {
 588       /* if exitpolicy includes a *:* line, then we're done. */
 589       return;
 590     }
 591   }
 592
 593   /* Else, append the default exitpolicy. */
 594   default_policy.key = NULL;
 595   default_policy.value = (char*)DEFAULT_EXIT_POLICY;
 596   default_policy.next = NULL;
 597   config_parse_addr_policy(&default_policy, &router->exit_policy);
 598 }
 599
 600 /** OR only: Check whether my exit policy says to allow connection to
 601  * conn.  Return false if we accept; true if we reject.
 602  */
 603 int router_compare_to_my_exit_policy(connection_t *conn)
 604 {
 605   tor_assert(desc_routerinfo);
 606
 607   /* make sure it's resolved to something. this way we can't get a
 608      'maybe' below. */
 609   if (!conn->addr)
 610     return -1;
 611
 612   return router_compare_addr_to_addr_policy(conn->addr, conn->port,
 613                    desc_routerinfo->exit_policy) != ADDR_POLICY_ACCEPTED;
 614
 615 }
 616
 617 /** Return true iff <b>router</b> has the same nickname as this OR.  (For an
 618  * OP, always returns false.)
 619  */
 620 int router_is_me(routerinfo_t *router)
 621 {
 622   routerinfo_t *me = router_get_my_routerinfo();
 623   tor_assert(router);
 624   if (!me || memcmp(me->identity_digest, router->identity_digest, DIGEST_LEN))
 625     return 0;
 626   return 1;
 627 }
 628
 629 /** Return a routerinfo for this OR, rebuilding a fresh one if
 630  * necessary.  Return NULL on error, or if called on an OP. */
 631 routerinfo_t *router_get_my_routerinfo(void)
 632 {
 633   if (!server_mode(get_options()))
 634     return NULL;
 635
 636   if (!desc_routerinfo) {
 637     if (router_rebuild_descriptor(1))
 638       return NULL;
 639   }
 640   return desc_routerinfo;
 641 }
 642
 643 /** OR only: Return a signed server descriptor for this OR, rebuilding a fresh
 644  * one if necessary.  Return NULL on error.
 645  */
 646 const char *router_get_my_descriptor(void) {
 647   if (!desc_routerinfo) {
 648     if (router_rebuild_descriptor(1))
 649       return NULL;
 650   }
 651   log_fn(LOG_DEBUG,"my desc is '%s'",desc_routerinfo->signed_descriptor);
 652   return desc_routerinfo->signed_descriptor;
 653 }
 654
 655 /** If <b>force</b> is true, or our descriptor is out-of-date, rebuild
 656  * a fresh routerinfo and signed server descriptor for this OR.
 657  * Return 0 on success, -1 on error.
 658  */
 659 int router_rebuild_descriptor(int force) {
 660   routerinfo_t *ri;
 661   uint32_t addr;
 662   char platform[256];
 663   struct in_addr in;
 664   int hibernating = we_are_hibernating();
 665   or_options_t *options = get_options();
 666   char addrbuf[INET_NTOA_BUF_LEN];
 667
 668   if (!desc_is_dirty && !force)
 669     return 0;
 670
 671   if (resolve_my_address(options->Address, &addr) < 0) {
 672     log_fn(LOG_WARN,"options->Address didn't resolve into an IP.");
 673     return -1;
 674   }
 675
 676   ri = tor_malloc_zero(sizeof(routerinfo_t));
 677   in.s_addr = htonl(addr);
 678   tor_inet_ntoa(&in, addrbuf, sizeof(addrbuf));
 679   ri->address = tor_strdup(addrbuf);
 680   ri->nickname = tor_strdup(options->Nickname);
 681   ri->addr = addr;
 682   ri->or_port = options->ORPort;
 683   ri->dir_port = hibernating ?
 684                  0 : options->DirPort;
 685   ri->published_on = time(NULL);
 686   ri->onion_pkey = crypto_pk_dup_key(get_onion_key()); /* must invoke from main thread */
 687   ri->identity_pkey = crypto_pk_dup_key(get_identity_key());
 688   if (crypto_pk_get_digest(ri->identity_pkey, ri->identity_digest)<0) {
 689     routerinfo_free(ri);
 690     return -1;
 691   }
 692   get_platform_str(platform, sizeof(platform));
 693   ri->platform = tor_strdup(platform);
 694   ri->bandwidthrate = (int)options->BandwidthRate;
 695   ri->bandwidthburst = (int)options->BandwidthBurst;
 696   ri->bandwidthcapacity = hibernating ? 0 : rep_hist_bandwidth_assess();
 697
 698   if (options->BandwidthRate > options->MaxAdvertisedBandwidth)
 699     ri->bandwidthrate = (int)options->MaxAdvertisedBandwidth;
 700
 701   router_add_exit_policy_from_config(ri);
 702   if (desc_routerinfo) /* inherit values */
 703     ri->is_verified = desc_routerinfo->is_verified;
 704   if (options->MyFamily) {
 705     ri->declared_family = smartlist_create();
 706     smartlist_split_string(ri->declared_family, options->MyFamily, ",",
 707                            SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
 708   }
 709   ri->signed_descriptor = tor_malloc(8192);
 710   if (router_dump_router_to_string(ri->signed_descriptor, 8192,
 711                                    ri, get_identity_key())<0) {
 712     log_fn(LOG_WARN, "Couldn't dump router to string.");
 713     return -1;
 714   }
 715
 716   if (desc_routerinfo)
 717     routerinfo_free(desc_routerinfo);
 718   desc_routerinfo = ri;
 719
 720   desc_is_dirty = 0;
 721   desc_needs_upload = 1;
 722   return 0;
 723 }
 724
 725 /** Call when the current descriptor is out of date. */
 726 void
 727 mark_my_descriptor_dirty(void)
 728 {
 729   desc_is_dirty = 1;
 730 }
 731
 732 /** Set <b>platform</b> (max length <b>len</b>) to a NUL-terminated short
 733  * string describing the version of Tor and the operating system we're
 734  * currently running on.
 735  */
 736 void get_platform_str(char *platform, size_t len)
 737 {
 738   tor_snprintf(platform, len, "Tor %s on %s",
 739            VERSION, get_uname());
 740   return;
 741 }
 742
 743 /* XXX need to audit this thing and count fenceposts. maybe
 744  *     refactor so we don't have to keep asking if we're
 745  *     near the end of maxlen?
 746  */
 747 #define DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
 748
 749 /** OR only: Given a routerinfo for this router, and an identity key to sign
 750  * with, encode the routerinfo as a signed server descriptor and write the
 751  * result into <b>s</b>, using at most <b>maxlen</b> bytes.  Return -1 on
 752  * failure, and the number of bytes used on success.
 753  */
 754 int router_dump_router_to_string(char *s, size_t maxlen, routerinfo_t *router,
 755                                  crypto_pk_env_t *ident_key) {
 756   char *onion_pkey; /* Onion key, PEM-encoded. */
 757   char *identity_pkey; /* Identity key, PEM-encoded. */
 758   char digest[20];
 759   char signature[128];
 760   char published[32];
 761   char fingerprint[FINGERPRINT_LEN+1];
 762   struct in_addr in;
 763   char addrbuf[INET_NTOA_BUF_LEN];
 764   size_t onion_pkeylen, identity_pkeylen;
 765   size_t written;
 766   int result=0;
 767   addr_policy_t *tmpe;
 768   char *bandwidth_usage;
 769   char *family_line;
 770 #ifdef DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
 771   char *s_tmp, *s_dup;
 772   const char *cp;
 773   routerinfo_t *ri_tmp;
 774 #endif
 775
 776   /* Make sure the identity key matches the one in the routerinfo. */
 777   if (crypto_pk_cmp_keys(ident_key, router->identity_pkey)) {
 778     log_fn(LOG_WARN,"Tried to sign a router with a private key that didn't match router's public key!");
 779     return -1;
 780   }
 781
 782   /* record our fingerprint, so we can include it in the descriptor */
 783   if (crypto_pk_get_fingerprint(router->identity_pkey, fingerprint, 1)<0) {
 784     log_fn(LOG_ERR, "Error computing fingerprint");
 785     return -1;
 786   }
 787
 788   /* PEM-encode the onion key */
 789   if (crypto_pk_write_public_key_to_string(router->onion_pkey,
 790                                            &onion_pkey,&onion_pkeylen)<0) {
 791     log_fn(LOG_WARN,"write onion_pkey to string failed!");
 792     return -1;
 793   }
 794
 795   /* PEM-encode the identity key key */
 796   if (crypto_pk_write_public_key_to_string(router->identity_pkey,
 797                                            &identity_pkey,&identity_pkeylen)<0) {
 798     log_fn(LOG_WARN,"write identity_pkey to string failed!");
 799     tor_free(onion_pkey);
 800     return -1;
 801   }
 802
 803   /* Encode the publication time. */
 804   format_iso_time(published, router->published_on);
 805
 806   /* How busy have we been? */
 807   bandwidth_usage = rep_hist_get_bandwidth_lines();
 808
 809   if (router->declared_family && smartlist_len(router->declared_family)) {
 810     size_t n;
 811     char *s = smartlist_join_strings(router->declared_family, " ", 0, &n);
 812     n += strlen("opt family ") + 2; /* 1 for \n, 1 for \0. */
 813     family_line = tor_malloc(n);
 814     tor_snprintf(family_line, n, "opt family %s\n", s);
 815     tor_free(s);
 816   } else {
 817     family_line = tor_strdup("");
 818   }
 819
 820   /* Generate the easy portion of the router descriptor. */
 821   result = tor_snprintf(s, maxlen,
 822                     "router %s %s %d 0 %d\n"
 823                     "platform %s\n"
 824                     "published %s\n"
 825                     "opt fingerprint %s\n"
 826                     "opt uptime %ld\n"
 827                     "bandwidth %d %d %d\n"
 828                     "onion-key\n%s"
 829                     "signing-key\n%s%s%s%s",
 830     router->nickname,
 831     router->address,
 832     router->or_port,
 833     check_whether_dirport_reachable ? router->dir_port : 0,
 834     router->platform,
 835     published,
 836     fingerprint,
 837     stats_n_seconds_working,
 838     (int) router->bandwidthrate,
 839     (int) router->bandwidthburst,
 840     (int) router->bandwidthcapacity,
 841     onion_pkey, identity_pkey,
 842     family_line, bandwidth_usage,
 843     we_are_hibernating() ? "opt hibernating 1\n" : "");
 844   tor_free(family_line);
 845   tor_free(onion_pkey);
 846   tor_free(identity_pkey);
 847   tor_free(bandwidth_usage);
 848
 849   if (result < 0)
 850     return -1;
 851   /* From now on, we use 'written' to remember the current length of 's'. */
 852   written = result;
 853
 854   if (get_options()->ContactInfo && strlen(get_options()->ContactInfo)) {
 855     result = tor_snprintf(s+written,maxlen-written, "opt contact %s\n",
 856                       get_options()->ContactInfo);
 857     if (result<0)
 858       return -1;
 859     written += result;
 860   }
 861
 862   /* Write the exit policy to the end of 's'. */
 863   for (tmpe=router->exit_policy; tmpe; tmpe=tmpe->next) {
 864     in.s_addr = htonl(tmpe->addr);
 865     /* Write: "accept 1.2.3.4" */
 866     tor_inet_ntoa(&in, addrbuf, sizeof(addrbuf));
 867     result = tor_snprintf(s+written, maxlen-written, "%s %s",
 868         tmpe->policy_type == ADDR_POLICY_ACCEPT ? "accept" : "reject",
 869         tmpe->msk == 0 ? "*" : addrbuf);
 870     if (result < 0)
 871       return -1;
 872     written += result;
 873     if (tmpe->msk != 0xFFFFFFFFu && tmpe->msk != 0) {
 874       /* Write "/255.255.0.0" */
 875       tor_inet_ntoa(&in, addrbuf, sizeof(addrbuf));
 876       in.s_addr = htonl(tmpe->msk);
 877       result = tor_snprintf(s+written, maxlen-written, "/%s", addrbuf);
 878       if (result<0)
 879         return -1;
 880       written += result;
 881     }
 882     if (tmpe->prt_min <= 1 && tmpe->prt_max == 65535) {
 883       /* There is no port set; write ":*" */
 884       if (written+4 > maxlen)
 885         return -1;
 886       strlcat(s+written, ":*\n", maxlen-written);
 887       written += 3;
 888     } else if (tmpe->prt_min == tmpe->prt_max) {
 889       /* There is only one port; write ":80". */
 890       result = tor_snprintf(s+written, maxlen-written, ":%d\n", tmpe->prt_min);
 891       if (result<0)
 892         return -1;
 893       written += result;
 894     } else {
 895       /* There is a range of ports; write ":79-80". */
 896       result = tor_snprintf(s+written, maxlen-written, ":%d-%d\n", tmpe->prt_min,
 897                         tmpe->prt_max);
 898       if (result<0)
 899         return -1;
 900       written += result;
 901     }
 902     if (tmpe->msk == 0 && tmpe->prt_min <= 1 && tmpe->prt_max == 65535)
 903       /* This was a catch-all rule, so future rules are irrelevant. */
 904       break;
 905   } /* end for */
 906   if (written+256 > maxlen) /* Not enough room for signature. */
 907     return -1;
 908
 909   /* Sign the directory */
 910   strlcat(s+written, "router-signature\n", maxlen-written);
 911   written += strlen(s+written);
 912   s[written] = '\0';
 913   if (router_get_router_hash(s, digest) < 0)
 914     return -1;
 915
 916   if (crypto_pk_private_sign(ident_key, signature, digest, 20) < 0) {
 917     log_fn(LOG_WARN, "Error signing digest");
 918     return -1;
 919   }
 920   strlcat(s+written, "-----BEGIN SIGNATURE-----\n", maxlen-written);
 921   written += strlen(s+written);
 922   if (base64_encode(s+written, maxlen-written, signature, 128) < 0) {
 923     log_fn(LOG_WARN, "Couldn't base64-encode signature");
 924     return -1;
 925   }
 926   written += strlen(s+written);
 927   strlcat(s+written, "-----END SIGNATURE-----\n", maxlen-written);
 928   written += strlen(s+written);
 929
 930   if (written+2 > maxlen)
 931     return -1;
 932   /* include a last '\n' */
 933   s[written] = '\n';
 934   s[written+1] = 0;
 935
 936 #ifdef DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
 937   cp = s_tmp = s_dup = tor_strdup(s);
 938   ri_tmp = router_parse_entry_from_string(cp, NULL);
 939   if (!ri_tmp) {
 940     log_fn(LOG_ERR, "We just generated a router descriptor we can't parse: <<%s>>",
 941            s);
 942     return -1;
 943   }
 944   tor_free(s_dup);
 945   routerinfo_free(ri_tmp);
 946 #endif
 947
 948   return written+1;
 949 }
 950
 951 /** Return true iff <b>s</b> is a legally valid server nickname. */
 952 int is_legal_nickname(const char *s)
 953 {
 954   size_t len;
 955   tor_assert(s);
 956   len = strlen(s);
 957   return len > 0 && len <= MAX_NICKNAME_LEN &&
 958     strspn(s,LEGAL_NICKNAME_CHARACTERS)==len;
 959 }
 960 /** Return true iff <b>s</b> is a legally valid server nickname or
 961  * hex-encoded identity-key digest. */
 962 int is_legal_nickname_or_hexdigest(const char *s)
 963 {
 964   size_t len;
 965   tor_assert(s);
 966   if (*s!='$')
 967     return is_legal_nickname(s);
 968
 969   len = strlen(s);
 970   return len == HEX_DIGEST_LEN+1 && strspn(s+1,HEX_CHARACTERS)==len-1;
 971 }
 972
 973 /** Release all resources held in router keys. */
 974 void router_free_all_keys(void)
 975 {
 976   if (onionkey)
 977     crypto_free_pk_env(onionkey);
 978   if (lastonionkey)
 979     crypto_free_pk_env(lastonionkey);
 980   if (identitykey)
 981     crypto_free_pk_env(identitykey);
 982   if (key_lock)
 983     tor_mutex_free(key_lock);
 984   if (desc_routerinfo)
 985     routerinfo_free(desc_routerinfo);
 986 }