router.c 100 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111
  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-2013, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. #define ROUTER_PRIVATE
  7. #include "or.h"
  8. #include "circuitbuild.h"
  9. #include "circuitlist.h"
  10. #include "circuituse.h"
  11. #include "config.h"
  12. #include "connection.h"
  13. #include "control.h"
  14. #include "crypto_curve25519.h"
  15. #include "directory.h"
  16. #include "dirserv.h"
  17. #include "dns.h"
  18. #include "geoip.h"
  19. #include "hibernate.h"
  20. #include "main.h"
  21. #include "networkstatus.h"
  22. #include "nodelist.h"
  23. #include "policies.h"
  24. #include "relay.h"
  25. #include "rephist.h"
  26. #include "router.h"
  27. #include "routerlist.h"
  28. #include "routerparse.h"
  29. #include "statefile.h"
  30. #include "transports.h"
  31. #include "routerset.h"
  32. /**
  33. * \file router.c
  34. * \brief OR functionality, including key maintenance, generating
  35. * and uploading server descriptors, retrying OR connections.
  36. **/
  37. extern long stats_n_seconds_working;
  38. /************************************************************/
  39. /*****
  40. * Key management: ORs only.
  41. *****/
  42. /** Private keys for this OR. There is also an SSL key managed by tortls.c.
  43. */
  44. static tor_mutex_t *key_lock=NULL;
  45. static time_t onionkey_set_at=0; /**< When was onionkey last changed? */
  46. /** Current private onionskin decryption key: used to decode CREATE cells. */
  47. static crypto_pk_t *onionkey=NULL;
  48. /** Previous private onionskin decryption key: used to decode CREATE cells
  49. * generated by clients that have an older version of our descriptor. */
  50. static crypto_pk_t *lastonionkey=NULL;
  51. #ifdef CURVE25519_ENABLED
  52. /** Current private ntor secret key: used to perform the ntor handshake. */
  53. static curve25519_keypair_t curve25519_onion_key;
  54. /** Previous private ntor secret key: used to perform the ntor handshake
  55. * with clients that have an older version of our descriptor. */
  56. static curve25519_keypair_t last_curve25519_onion_key;
  57. #endif
  58. /** Private server "identity key": used to sign directory info and TLS
  59. * certificates. Never changes. */
  60. static crypto_pk_t *server_identitykey=NULL;
  61. /** Digest of server_identitykey. */
  62. static char server_identitykey_digest[DIGEST_LEN];
  63. /** Private client "identity key": used to sign bridges' and clients'
  64. * outbound TLS certificates. Regenerated on startup and on IP address
  65. * change. */
  66. static crypto_pk_t *client_identitykey=NULL;
  67. /** Signing key used for v3 directory material; only set for authorities. */
  68. static crypto_pk_t *authority_signing_key = NULL;
  69. /** Key certificate to authenticate v3 directory material; only set for
  70. * authorities. */
  71. static authority_cert_t *authority_key_certificate = NULL;
  72. /** For emergency V3 authority key migration: An extra signing key that we use
  73. * with our old (obsolete) identity key for a while. */
  74. static crypto_pk_t *legacy_signing_key = NULL;
  75. /** For emergency V3 authority key migration: An extra certificate to
  76. * authenticate legacy_signing_key with our obsolete identity key.*/
  77. static authority_cert_t *legacy_key_certificate = NULL;
  78. /* (Note that v3 authorities also have a separate "authority identity key",
  79. * but this key is never actually loaded by the Tor process. Instead, it's
  80. * used by tor-gencert to sign new signing keys and make new key
  81. * certificates. */
  82. /** Replace the current onion key with <b>k</b>. Does not affect
  83. * lastonionkey; to update lastonionkey correctly, call rotate_onion_key().
  84. */
  85. static void
  86. set_onion_key(crypto_pk_t *k)
  87. {
  88. if (onionkey && crypto_pk_eq_keys(onionkey, k)) {
  89. /* k is already our onion key; free it and return */
  90. crypto_pk_free(k);
  91. return;
  92. }
  93. tor_mutex_acquire(key_lock);
  94. crypto_pk_free(onionkey);
  95. onionkey = k;
  96. tor_mutex_release(key_lock);
  97. mark_my_descriptor_dirty("set onion key");
  98. }
  99. /** Return the current onion key. Requires that the onion key has been
  100. * loaded or generated. */
  101. crypto_pk_t *
  102. get_onion_key(void)
  103. {
  104. tor_assert(onionkey);
  105. return onionkey;
  106. }
  107. /** Store a full copy of the current onion key into *<b>key</b>, and a full
  108. * copy of the most recent onion key into *<b>last</b>.
  109. */
  110. void
  111. dup_onion_keys(crypto_pk_t **key, crypto_pk_t **last)
  112. {
  113. tor_assert(key);
  114. tor_assert(last);
  115. tor_mutex_acquire(key_lock);
  116. tor_assert(onionkey);
  117. *key = crypto_pk_copy_full(onionkey);
  118. if (lastonionkey)
  119. *last = crypto_pk_copy_full(lastonionkey);
  120. else
  121. *last = NULL;
  122. tor_mutex_release(key_lock);
  123. }
  124. #ifdef CURVE25519_ENABLED
  125. /** Return the current secret onion key for the ntor handshake. Must only
  126. * be called from the main thread. */
  127. static const curve25519_keypair_t *
  128. get_current_curve25519_keypair(void)
  129. {
  130. return &curve25519_onion_key;
  131. }
  132. /** Return a map from KEYID (the key itself) to keypairs for use in the ntor
  133. * handshake. Must only be called from the main thread. */
  134. di_digest256_map_t *
  135. construct_ntor_key_map(void)
  136. {
  137. di_digest256_map_t *m = NULL;
  138. dimap_add_entry(&m,
  139. curve25519_onion_key.pubkey.public_key,
  140. tor_memdup(&curve25519_onion_key,
  141. sizeof(curve25519_keypair_t)));
  142. if (!tor_mem_is_zero((const char*)
  143. last_curve25519_onion_key.pubkey.public_key,
  144. CURVE25519_PUBKEY_LEN)) {
  145. dimap_add_entry(&m,
  146. last_curve25519_onion_key.pubkey.public_key,
  147. tor_memdup(&last_curve25519_onion_key,
  148. sizeof(curve25519_keypair_t)));
  149. }
  150. return m;
  151. }
  152. /** Helper used to deallocate a di_digest256_map_t returned by
  153. * construct_ntor_key_map. */
  154. static void
  155. ntor_key_map_free_helper(void *arg)
  156. {
  157. curve25519_keypair_t *k = arg;
  158. memwipe(k, 0, sizeof(*k));
  159. tor_free(k);
  160. }
  161. /** Release all storage from a keymap returned by construct_ntor_key_map. */
  162. void
  163. ntor_key_map_free(di_digest256_map_t *map)
  164. {
  165. if (!map)
  166. return;
  167. dimap_free(map, ntor_key_map_free_helper);
  168. }
  169. #endif
  170. /** Return the time when the onion key was last set. This is either the time
  171. * when the process launched, or the time of the most recent key rotation since
  172. * the process launched.
  173. */
  174. time_t
  175. get_onion_key_set_at(void)
  176. {
  177. return onionkey_set_at;
  178. }
  179. /** Set the current server identity key to <b>k</b>.
  180. */
  181. void
  182. set_server_identity_key(crypto_pk_t *k)
  183. {
  184. crypto_pk_free(server_identitykey);
  185. server_identitykey = k;
  186. crypto_pk_get_digest(server_identitykey, server_identitykey_digest);
  187. }
  188. /** Make sure that we have set up our identity keys to match or not match as
  189. * appropriate, and die with an assertion if we have not. */
  190. static void
  191. assert_identity_keys_ok(void)
  192. {
  193. tor_assert(client_identitykey);
  194. if (public_server_mode(get_options())) {
  195. /* assert that we have set the client and server keys to be equal */
  196. tor_assert(server_identitykey);
  197. tor_assert(crypto_pk_eq_keys(client_identitykey, server_identitykey));
  198. } else {
  199. /* assert that we have set the client and server keys to be unequal */
  200. if (server_identitykey)
  201. tor_assert(!crypto_pk_eq_keys(client_identitykey, server_identitykey));
  202. }
  203. }
  204. /** Returns the current server identity key; requires that the key has
  205. * been set, and that we are running as a Tor server.
  206. */
  207. crypto_pk_t *
  208. get_server_identity_key(void)
  209. {
  210. tor_assert(server_identitykey);
  211. tor_assert(server_mode(get_options()));
  212. assert_identity_keys_ok();
  213. return server_identitykey;
  214. }
  215. /** Return true iff we are a server and the server identity key
  216. * has been set. */
  217. int
  218. server_identity_key_is_set(void)
  219. {
  220. return server_mode(get_options()) && server_identitykey != NULL;
  221. }
  222. /** Set the current client identity key to <b>k</b>.
  223. */
  224. void
  225. set_client_identity_key(crypto_pk_t *k)
  226. {
  227. crypto_pk_free(client_identitykey);
  228. client_identitykey = k;
  229. }
  230. /** Returns the current client identity key for use on outgoing TLS
  231. * connections; requires that the key has been set.
  232. */
  233. crypto_pk_t *
  234. get_tlsclient_identity_key(void)
  235. {
  236. tor_assert(client_identitykey);
  237. assert_identity_keys_ok();
  238. return client_identitykey;
  239. }
  240. /** Return true iff the client identity key has been set. */
  241. int
  242. client_identity_key_is_set(void)
  243. {
  244. return client_identitykey != NULL;
  245. }
  246. /** Return the key certificate for this v3 (voting) authority, or NULL
  247. * if we have no such certificate. */
  248. authority_cert_t *
  249. get_my_v3_authority_cert(void)
  250. {
  251. return authority_key_certificate;
  252. }
  253. /** Return the v3 signing key for this v3 (voting) authority, or NULL
  254. * if we have no such key. */
  255. crypto_pk_t *
  256. get_my_v3_authority_signing_key(void)
  257. {
  258. return authority_signing_key;
  259. }
  260. /** If we're an authority, and we're using a legacy authority identity key for
  261. * emergency migration purposes, return the certificate associated with that
  262. * key. */
  263. authority_cert_t *
  264. get_my_v3_legacy_cert(void)
  265. {
  266. return legacy_key_certificate;
  267. }
  268. /** If we're an authority, and we're using a legacy authority identity key for
  269. * emergency migration purposes, return that key. */
  270. crypto_pk_t *
  271. get_my_v3_legacy_signing_key(void)
  272. {
  273. return legacy_signing_key;
  274. }
  275. /** Replace the previous onion key with the current onion key, and generate
  276. * a new previous onion key. Immediately after calling this function,
  277. * the OR should:
  278. * - schedule all previous cpuworkers to shut down _after_ processing
  279. * pending work. (This will cause fresh cpuworkers to be generated.)
  280. * - generate and upload a fresh routerinfo.
  281. */
  282. void
  283. rotate_onion_key(void)
  284. {
  285. char *fname, *fname_prev;
  286. crypto_pk_t *prkey = NULL;
  287. or_state_t *state = get_or_state();
  288. #ifdef CURVE25519_ENABLED
  289. curve25519_keypair_t new_curve25519_keypair;
  290. #endif
  291. time_t now;
  292. fname = get_datadir_fname2("keys", "secret_onion_key");
  293. fname_prev = get_datadir_fname2("keys", "secret_onion_key.old");
  294. if (file_status(fname) == FN_FILE) {
  295. if (replace_file(fname, fname_prev))
  296. goto error;
  297. }
  298. if (!(prkey = crypto_pk_new())) {
  299. log_err(LD_GENERAL,"Error constructing rotated onion key");
  300. goto error;
  301. }
  302. if (crypto_pk_generate_key(prkey)) {
  303. log_err(LD_BUG,"Error generating onion key");
  304. goto error;
  305. }
  306. if (crypto_pk_write_private_key_to_filename(prkey, fname)) {
  307. log_err(LD_FS,"Couldn't write generated onion key to \"%s\".", fname);
  308. goto error;
  309. }
  310. #ifdef CURVE25519_ENABLED
  311. tor_free(fname);
  312. tor_free(fname_prev);
  313. fname = get_datadir_fname2("keys", "secret_onion_key_ntor");
  314. fname_prev = get_datadir_fname2("keys", "secret_onion_key_ntor.old");
  315. if (curve25519_keypair_generate(&new_curve25519_keypair, 1) < 0)
  316. goto error;
  317. if (file_status(fname) == FN_FILE) {
  318. if (replace_file(fname, fname_prev))
  319. goto error;
  320. }
  321. if (curve25519_keypair_write_to_file(&new_curve25519_keypair, fname,
  322. "onion") < 0) {
  323. log_err(LD_FS,"Couldn't write curve25519 onion key to \"%s\".",fname);
  324. goto error;
  325. }
  326. #endif
  327. log_info(LD_GENERAL, "Rotating onion key");
  328. tor_mutex_acquire(key_lock);
  329. crypto_pk_free(lastonionkey);
  330. lastonionkey = onionkey;
  331. onionkey = prkey;
  332. #ifdef CURVE25519_ENABLED
  333. memcpy(&last_curve25519_onion_key, &curve25519_onion_key,
  334. sizeof(curve25519_keypair_t));
  335. memcpy(&curve25519_onion_key, &new_curve25519_keypair,
  336. sizeof(curve25519_keypair_t));
  337. #endif
  338. now = time(NULL);
  339. state->LastRotatedOnionKey = onionkey_set_at = now;
  340. tor_mutex_release(key_lock);
  341. mark_my_descriptor_dirty("rotated onion key");
  342. or_state_mark_dirty(state, get_options()->AvoidDiskWrites ? now+3600 : 0);
  343. goto done;
  344. error:
  345. log_warn(LD_GENERAL, "Couldn't rotate onion key.");
  346. if (prkey)
  347. crypto_pk_free(prkey);
  348. done:
  349. #ifdef CURVE25519_ENABLED
  350. memwipe(&new_curve25519_keypair, 0, sizeof(new_curve25519_keypair));
  351. #endif
  352. tor_free(fname);
  353. tor_free(fname_prev);
  354. }
  355. /** Try to read an RSA key from <b>fname</b>. If <b>fname</b> doesn't exist
  356. * and <b>generate</b> is true, create a new RSA key and save it in
  357. * <b>fname</b>. Return the read/created key, or NULL on error. Log all
  358. * errors at level <b>severity</b>.
  359. */
  360. crypto_pk_t *
  361. init_key_from_file(const char *fname, int generate, int severity)
  362. {
  363. crypto_pk_t *prkey = NULL;
  364. if (!(prkey = crypto_pk_new())) {
  365. tor_log(severity, LD_GENERAL,"Error constructing key");
  366. goto error;
  367. }
  368. switch (file_status(fname)) {
  369. case FN_DIR:
  370. case FN_ERROR:
  371. tor_log(severity, LD_FS,"Can't read key from \"%s\"", fname);
  372. goto error;
  373. case FN_NOENT:
  374. if (generate) {
  375. if (!have_lockfile()) {
  376. if (try_locking(get_options(), 0)<0) {
  377. /* Make sure that --list-fingerprint only creates new keys
  378. * if there is no possibility for a deadlock. */
  379. tor_log(severity, LD_FS, "Another Tor process has locked \"%s\". "
  380. "Not writing any new keys.", fname);
  381. /*XXXX The 'other process' might make a key in a second or two;
  382. * maybe we should wait for it. */
  383. goto error;
  384. }
  385. }
  386. log_info(LD_GENERAL, "No key found in \"%s\"; generating fresh key.",
  387. fname);
  388. if (crypto_pk_generate_key(prkey)) {
  389. tor_log(severity, LD_GENERAL,"Error generating onion key");
  390. goto error;
  391. }
  392. if (crypto_pk_check_key(prkey) <= 0) {
  393. tor_log(severity, LD_GENERAL,"Generated key seems invalid");
  394. goto error;
  395. }
  396. log_info(LD_GENERAL, "Generated key seems valid");
  397. if (crypto_pk_write_private_key_to_filename(prkey, fname)) {
  398. tor_log(severity, LD_FS,
  399. "Couldn't write generated key to \"%s\".", fname);
  400. goto error;
  401. }
  402. } else {
  403. log_info(LD_GENERAL, "No key found in \"%s\"", fname);
  404. }
  405. return prkey;
  406. case FN_FILE:
  407. if (crypto_pk_read_private_key_from_filename(prkey, fname)) {
  408. tor_log(severity, LD_GENERAL,"Error loading private key.");
  409. goto error;
  410. }
  411. return prkey;
  412. default:
  413. tor_assert(0);
  414. }
  415. error:
  416. if (prkey)
  417. crypto_pk_free(prkey);
  418. return NULL;
  419. }
  420. #ifdef CURVE25519_ENABLED
  421. /** Load a curve25519 keypair from the file <b>fname</b>, writing it into
  422. * <b>keys_out</b>. If the file isn't found and <b>generate</b> is true,
  423. * create a new keypair and write it into the file. If there are errors, log
  424. * them at level <b>severity</b>. Generate files using <b>tag</b> in their
  425. * ASCII wrapper. */
  426. static int
  427. init_curve25519_keypair_from_file(curve25519_keypair_t *keys_out,
  428. const char *fname,
  429. int generate,
  430. int severity,
  431. const char *tag)
  432. {
  433. switch (file_status(fname)) {
  434. case FN_DIR:
  435. case FN_ERROR:
  436. tor_log(severity, LD_FS,"Can't read key from \"%s\"", fname);
  437. goto error;
  438. case FN_NOENT:
  439. if (generate) {
  440. if (!have_lockfile()) {
  441. if (try_locking(get_options(), 0)<0) {
  442. /* Make sure that --list-fingerprint only creates new keys
  443. * if there is no possibility for a deadlock. */
  444. tor_log(severity, LD_FS, "Another Tor process has locked \"%s\". "
  445. "Not writing any new keys.", fname);
  446. /*XXXX The 'other process' might make a key in a second or two;
  447. * maybe we should wait for it. */
  448. goto error;
  449. }
  450. }
  451. log_info(LD_GENERAL, "No key found in \"%s\"; generating fresh key.",
  452. fname);
  453. if (curve25519_keypair_generate(keys_out, 1) < 0)
  454. goto error;
  455. if (curve25519_keypair_write_to_file(keys_out, fname, tag)<0) {
  456. tor_log(severity, LD_FS,
  457. "Couldn't write generated key to \"%s\".", fname);
  458. memset(keys_out, 0, sizeof(*keys_out));
  459. goto error;
  460. }
  461. } else {
  462. log_info(LD_GENERAL, "No key found in \"%s\"", fname);
  463. }
  464. return 0;
  465. case FN_FILE:
  466. {
  467. char *tag_in=NULL;
  468. if (curve25519_keypair_read_from_file(keys_out, &tag_in, fname) < 0) {
  469. tor_log(severity, LD_GENERAL,"Error loading private key.");
  470. tor_free(tag_in);
  471. goto error;
  472. }
  473. if (!tag_in || strcmp(tag_in, tag)) {
  474. tor_log(severity, LD_GENERAL,"Unexpected tag %s on private key.",
  475. escaped(tag_in));
  476. tor_free(tag_in);
  477. goto error;
  478. }
  479. tor_free(tag_in);
  480. return 0;
  481. }
  482. default:
  483. tor_assert(0);
  484. }
  485. error:
  486. return -1;
  487. }
  488. #endif
  489. /** Try to load the vote-signing private key and certificate for being a v3
  490. * directory authority, and make sure they match. If <b>legacy</b>, load a
  491. * legacy key/cert set for emergency key migration; otherwise load the regular
  492. * key/cert set. On success, store them into *<b>key_out</b> and
  493. * *<b>cert_out</b> respectively, and return 0. On failure, return -1. */
  494. static int
  495. load_authority_keyset(int legacy, crypto_pk_t **key_out,
  496. authority_cert_t **cert_out)
  497. {
  498. int r = -1;
  499. char *fname = NULL, *cert = NULL;
  500. const char *eos = NULL;
  501. crypto_pk_t *signing_key = NULL;
  502. authority_cert_t *parsed = NULL;
  503. fname = get_datadir_fname2("keys",
  504. legacy ? "legacy_signing_key" : "authority_signing_key");
  505. signing_key = init_key_from_file(fname, 0, LOG_INFO);
  506. if (!signing_key) {
  507. log_warn(LD_DIR, "No version 3 directory key found in %s", fname);
  508. goto done;
  509. }
  510. tor_free(fname);
  511. fname = get_datadir_fname2("keys",
  512. legacy ? "legacy_certificate" : "authority_certificate");
  513. cert = read_file_to_str(fname, 0, NULL);
  514. if (!cert) {
  515. log_warn(LD_DIR, "Signing key found, but no certificate found in %s",
  516. fname);
  517. goto done;
  518. }
  519. parsed = authority_cert_parse_from_string(cert, &eos);
  520. if (!parsed) {
  521. log_warn(LD_DIR, "Unable to parse certificate in %s", fname);
  522. goto done;
  523. }
  524. if (!crypto_pk_eq_keys(signing_key, parsed->signing_key)) {
  525. log_warn(LD_DIR, "Stored signing key does not match signing key in "
  526. "certificate");
  527. goto done;
  528. }
  529. crypto_pk_free(*key_out);
  530. authority_cert_free(*cert_out);
  531. *key_out = signing_key;
  532. *cert_out = parsed;
  533. r = 0;
  534. signing_key = NULL;
  535. parsed = NULL;
  536. done:
  537. tor_free(fname);
  538. tor_free(cert);
  539. crypto_pk_free(signing_key);
  540. authority_cert_free(parsed);
  541. return r;
  542. }
  543. /** Load the v3 (voting) authority signing key and certificate, if they are
  544. * present. Return -1 if anything is missing, mismatched, or unloadable;
  545. * return 0 on success. */
  546. static int
  547. init_v3_authority_keys(void)
  548. {
  549. if (load_authority_keyset(0, &authority_signing_key,
  550. &authority_key_certificate)<0)
  551. return -1;
  552. if (get_options()->V3AuthUseLegacyKey &&
  553. load_authority_keyset(1, &legacy_signing_key,
  554. &legacy_key_certificate)<0)
  555. return -1;
  556. return 0;
  557. }
  558. /** If we're a v3 authority, check whether we have a certificate that's
  559. * likely to expire soon. Warn if we do, but not too often. */
  560. void
  561. v3_authority_check_key_expiry(void)
  562. {
  563. time_t now, expires;
  564. static time_t last_warned = 0;
  565. int badness, time_left, warn_interval;
  566. if (!authdir_mode_v3(get_options()) || !authority_key_certificate)
  567. return;
  568. now = time(NULL);
  569. expires = authority_key_certificate->expires;
  570. time_left = (int)( expires - now );
  571. if (time_left <= 0) {
  572. badness = LOG_ERR;
  573. warn_interval = 60*60;
  574. } else if (time_left <= 24*60*60) {
  575. badness = LOG_WARN;
  576. warn_interval = 60*60;
  577. } else if (time_left <= 24*60*60*7) {
  578. badness = LOG_WARN;
  579. warn_interval = 24*60*60;
  580. } else if (time_left <= 24*60*60*30) {
  581. badness = LOG_WARN;
  582. warn_interval = 24*60*60*5;
  583. } else {
  584. return;
  585. }
  586. if (last_warned + warn_interval > now)
  587. return;
  588. if (time_left <= 0) {
  589. tor_log(badness, LD_DIR, "Your v3 authority certificate has expired."
  590. " Generate a new one NOW.");
  591. } else if (time_left <= 24*60*60) {
  592. tor_log(badness, LD_DIR, "Your v3 authority certificate expires in %d "
  593. "hours; Generate a new one NOW.", time_left/(60*60));
  594. } else {
  595. tor_log(badness, LD_DIR, "Your v3 authority certificate expires in %d "
  596. "days; Generate a new one soon.", time_left/(24*60*60));
  597. }
  598. last_warned = now;
  599. }
  600. /** Set up Tor's TLS contexts, based on our configuration and keys. Return 0
  601. * on success, and -1 on failure. */
  602. int
  603. router_initialize_tls_context(void)
  604. {
  605. unsigned int flags = 0;
  606. const or_options_t *options = get_options();
  607. int lifetime = options->SSLKeyLifetime;
  608. if (public_server_mode(options))
  609. flags |= TOR_TLS_CTX_IS_PUBLIC_SERVER;
  610. if (options->TLSECGroup) {
  611. if (!strcasecmp(options->TLSECGroup, "P256"))
  612. flags |= TOR_TLS_CTX_USE_ECDHE_P256;
  613. else if (!strcasecmp(options->TLSECGroup, "P224"))
  614. flags |= TOR_TLS_CTX_USE_ECDHE_P224;
  615. }
  616. if (!lifetime) { /* we should guess a good ssl cert lifetime */
  617. /* choose between 5 and 365 days, and round to the day */
  618. lifetime = 5*24*3600 + crypto_rand_int(361*24*3600);
  619. lifetime -= lifetime % (24*3600);
  620. if (crypto_rand_int(2)) {
  621. /* Half the time we expire at midnight, and half the time we expire
  622. * one second before midnight. (Some CAs wobble their expiry times a
  623. * bit in practice, perhaps to reduce collision attacks; see ticket
  624. * 8443 for details about observed certs in the wild.) */
  625. lifetime--;
  626. }
  627. }
  628. /* It's ok to pass lifetime in as an unsigned int, since
  629. * config_parse_interval() checked it. */
  630. return tor_tls_context_init(flags,
  631. get_tlsclient_identity_key(),
  632. server_mode(options) ?
  633. get_server_identity_key() : NULL,
  634. (unsigned int)lifetime);
  635. }
  636. /** Compute fingerprint (or hashed fingerprint if hashed is 1) and write
  637. * it to 'fingerprint' (or 'hashed-fingerprint'). Return 0 on success, or
  638. * -1 if Tor should die,
  639. */
  640. STATIC int
  641. router_write_fingerprint(int hashed)
  642. {
  643. char *keydir = NULL, *cp = NULL;
  644. const char *fname = hashed ? "hashed-fingerprint" :
  645. "fingerprint";
  646. char fingerprint[FINGERPRINT_LEN+1];
  647. const or_options_t *options = get_options();
  648. char *fingerprint_line = NULL;
  649. int result = -1;
  650. keydir = get_datadir_fname(fname);
  651. log_info(LD_GENERAL,"Dumping %sfingerprint to \"%s\"...",
  652. hashed ? "hashed " : "", keydir);
  653. if (!hashed) {
  654. if (crypto_pk_get_fingerprint(get_server_identity_key(),
  655. fingerprint, 0) < 0) {
  656. log_err(LD_GENERAL,"Error computing fingerprint");
  657. goto done;
  658. }
  659. } else {
  660. if (crypto_pk_get_hashed_fingerprint(get_server_identity_key(),
  661. fingerprint) < 0) {
  662. log_err(LD_GENERAL,"Error computing hashed fingerprint");
  663. goto done;
  664. }
  665. }
  666. tor_asprintf(&fingerprint_line, "%s %s\n", options->Nickname, fingerprint);
  667. /* Check whether we need to write the (hashed-)fingerprint file. */
  668. cp = read_file_to_str(keydir, RFTS_IGNORE_MISSING, NULL);
  669. if (!cp || strcmp(cp, fingerprint_line)) {
  670. if (write_str_to_file(keydir, fingerprint_line, 0)) {
  671. log_err(LD_FS, "Error writing %sfingerprint line to file",
  672. hashed ? "hashed " : "");
  673. goto done;
  674. }
  675. }
  676. log_notice(LD_GENERAL, "Your Tor %s identity key fingerprint is '%s %s'",
  677. hashed ? "bridge's hashed" : "server's", options->Nickname,
  678. fingerprint);
  679. result = 0;
  680. done:
  681. tor_free(cp);
  682. tor_free(keydir);
  683. tor_free(fingerprint_line);
  684. return result;
  685. }
  686. /** Initialize all OR private keys, and the TLS context, as necessary.
  687. * On OPs, this only initializes the tls context. Return 0 on success,
  688. * or -1 if Tor should die.
  689. */
  690. int
  691. init_keys(void)
  692. {
  693. char *keydir;
  694. const char *mydesc;
  695. crypto_pk_t *prkey;
  696. char digest[DIGEST_LEN];
  697. char v3_digest[DIGEST_LEN];
  698. const or_options_t *options = get_options();
  699. dirinfo_type_t type;
  700. time_t now = time(NULL);
  701. dir_server_t *ds;
  702. int v3_digest_set = 0;
  703. authority_cert_t *cert = NULL;
  704. if (!key_lock)
  705. key_lock = tor_mutex_new();
  706. /* There are a couple of paths that put us here before we've asked
  707. * openssl to initialize itself. */
  708. if (crypto_global_init(get_options()->HardwareAccel,
  709. get_options()->AccelName,
  710. get_options()->AccelDir)) {
  711. log_err(LD_BUG, "Unable to initialize OpenSSL. Exiting.");
  712. return -1;
  713. }
  714. /* OP's don't need persistent keys; just make up an identity and
  715. * initialize the TLS context. */
  716. if (!server_mode(options)) {
  717. if (!(prkey = crypto_pk_new()))
  718. return -1;
  719. if (crypto_pk_generate_key(prkey)) {
  720. crypto_pk_free(prkey);
  721. return -1;
  722. }
  723. set_client_identity_key(prkey);
  724. /* Create a TLS context. */
  725. if (router_initialize_tls_context() < 0) {
  726. log_err(LD_GENERAL,"Error creating TLS context for Tor client.");
  727. return -1;
  728. }
  729. return 0;
  730. }
  731. /* Make sure DataDirectory exists, and is private. */
  732. if (check_private_dir(options->DataDirectory, CPD_CREATE, options->User)) {
  733. return -1;
  734. }
  735. /* Check the key directory. */
  736. keydir = get_datadir_fname("keys");
  737. if (check_private_dir(keydir, CPD_CREATE, options->User)) {
  738. tor_free(keydir);
  739. return -1;
  740. }
  741. tor_free(keydir);
  742. /* 1a. Read v3 directory authority key/cert information. */
  743. memset(v3_digest, 0, sizeof(v3_digest));
  744. if (authdir_mode_v3(options)) {
  745. if (init_v3_authority_keys()<0) {
  746. log_err(LD_GENERAL, "We're configured as a V3 authority, but we "
  747. "were unable to load our v3 authority keys and certificate! "
  748. "Use tor-gencert to generate them. Dying.");
  749. return -1;
  750. }
  751. cert = get_my_v3_authority_cert();
  752. if (cert) {
  753. crypto_pk_get_digest(get_my_v3_authority_cert()->identity_key,
  754. v3_digest);
  755. v3_digest_set = 1;
  756. }
  757. }
  758. /* 1b. Read identity key. Make it if none is found. */
  759. keydir = get_datadir_fname2("keys", "secret_id_key");
  760. log_info(LD_GENERAL,"Reading/making identity key \"%s\"...",keydir);
  761. prkey = init_key_from_file(keydir, 1, LOG_ERR);
  762. tor_free(keydir);
  763. if (!prkey) return -1;
  764. set_server_identity_key(prkey);
  765. /* 1c. If we are configured as a bridge, generate a client key;
  766. * otherwise, set the server identity key as our client identity
  767. * key. */
  768. if (public_server_mode(options)) {
  769. set_client_identity_key(crypto_pk_dup_key(prkey)); /* set above */
  770. } else {
  771. if (!(prkey = crypto_pk_new()))
  772. return -1;
  773. if (crypto_pk_generate_key(prkey)) {
  774. crypto_pk_free(prkey);
  775. return -1;
  776. }
  777. set_client_identity_key(prkey);
  778. }
  779. /* 2. Read onion key. Make it if none is found. */
  780. keydir = get_datadir_fname2("keys", "secret_onion_key");
  781. log_info(LD_GENERAL,"Reading/making onion key \"%s\"...",keydir);
  782. prkey = init_key_from_file(keydir, 1, LOG_ERR);
  783. tor_free(keydir);
  784. if (!prkey) return -1;
  785. set_onion_key(prkey);
  786. if (options->command == CMD_RUN_TOR) {
  787. /* only mess with the state file if we're actually running Tor */
  788. or_state_t *state = get_or_state();
  789. if (state->LastRotatedOnionKey > 100 && state->LastRotatedOnionKey < now) {
  790. /* We allow for some parsing slop, but we don't want to risk accepting
  791. * values in the distant future. If we did, we might never rotate the
  792. * onion key. */
  793. onionkey_set_at = state->LastRotatedOnionKey;
  794. } else {
  795. /* We have no LastRotatedOnionKey set; either we just created the key
  796. * or it's a holdover from 0.1.2.4-alpha-dev or earlier. In either case,
  797. * start the clock ticking now so that we will eventually rotate it even
  798. * if we don't stay up for a full MIN_ONION_KEY_LIFETIME. */
  799. state->LastRotatedOnionKey = onionkey_set_at = now;
  800. or_state_mark_dirty(state, options->AvoidDiskWrites ?
  801. time(NULL)+3600 : 0);
  802. }
  803. }
  804. keydir = get_datadir_fname2("keys", "secret_onion_key.old");
  805. if (!lastonionkey && file_status(keydir) == FN_FILE) {
  806. prkey = init_key_from_file(keydir, 1, LOG_ERR); /* XXXX Why 1? */
  807. if (prkey)
  808. lastonionkey = prkey;
  809. }
  810. tor_free(keydir);
  811. #ifdef CURVE25519_ENABLED
  812. {
  813. /* 2b. Load curve25519 onion keys. */
  814. int r;
  815. keydir = get_datadir_fname2("keys", "secret_onion_key_ntor");
  816. r = init_curve25519_keypair_from_file(&curve25519_onion_key,
  817. keydir, 1, LOG_ERR, "onion");
  818. tor_free(keydir);
  819. if (r<0)
  820. return -1;
  821. keydir = get_datadir_fname2("keys", "secret_onion_key_ntor.old");
  822. if (tor_mem_is_zero((const char *)
  823. last_curve25519_onion_key.pubkey.public_key,
  824. CURVE25519_PUBKEY_LEN) &&
  825. file_status(keydir) == FN_FILE) {
  826. init_curve25519_keypair_from_file(&last_curve25519_onion_key,
  827. keydir, 0, LOG_ERR, "onion");
  828. }
  829. tor_free(keydir);
  830. }
  831. #endif
  832. /* 3. Initialize link key and TLS context. */
  833. if (router_initialize_tls_context() < 0) {
  834. log_err(LD_GENERAL,"Error initializing TLS context");
  835. return -1;
  836. }
  837. /* 4. Build our router descriptor. */
  838. /* Must be called after keys are initialized. */
  839. mydesc = router_get_my_descriptor();
  840. if (authdir_mode_handles_descs(options, ROUTER_PURPOSE_GENERAL)) {
  841. const char *m = NULL;
  842. routerinfo_t *ri;
  843. /* We need to add our own fingerprint so it gets recognized. */
  844. if (dirserv_add_own_fingerprint(options->Nickname,
  845. get_server_identity_key())) {
  846. log_err(LD_GENERAL,"Error adding own fingerprint to approved set");
  847. return -1;
  848. }
  849. if (mydesc) {
  850. was_router_added_t added;
  851. ri = router_parse_entry_from_string(mydesc, NULL, 1, 0, NULL);
  852. if (!ri) {
  853. log_err(LD_GENERAL,"Generated a routerinfo we couldn't parse.");
  854. return -1;
  855. }
  856. added = dirserv_add_descriptor(ri, &m, "self");
  857. if (!WRA_WAS_ADDED(added)) {
  858. if (!WRA_WAS_OUTDATED(added)) {
  859. log_err(LD_GENERAL, "Unable to add own descriptor to directory: %s",
  860. m?m:"<unknown error>");
  861. return -1;
  862. } else {
  863. /* If the descriptor was outdated, that's ok. This can happen
  864. * when some config options are toggled that affect workers, but
  865. * we don't really need new keys yet so the descriptor doesn't
  866. * change and the old one is still fresh. */
  867. log_info(LD_GENERAL, "Couldn't add own descriptor to directory "
  868. "after key init: %s This is usually not a problem.",
  869. m?m:"<unknown error>");
  870. }
  871. }
  872. }
  873. }
  874. /* 5. Dump fingerprint and possibly hashed fingerprint to files. */
  875. if (router_write_fingerprint(0)) {
  876. log_err(LD_FS, "Error writing fingerprint to file");
  877. return -1;
  878. }
  879. if (!public_server_mode(options) && router_write_fingerprint(1)) {
  880. log_err(LD_FS, "Error writing hashed fingerprint to file");
  881. return -1;
  882. }
  883. if (!authdir_mode(options))
  884. return 0;
  885. /* 6. [authdirserver only] load approved-routers file */
  886. if (dirserv_load_fingerprint_file() < 0) {
  887. log_err(LD_GENERAL,"Error loading fingerprints");
  888. return -1;
  889. }
  890. /* 6b. [authdirserver only] add own key to approved directories. */
  891. crypto_pk_get_digest(get_server_identity_key(), digest);
  892. type = ((options->V3AuthoritativeDir ?
  893. (V3_DIRINFO|MICRODESC_DIRINFO|EXTRAINFO_DIRINFO) : NO_DIRINFO) |
  894. (options->BridgeAuthoritativeDir ? BRIDGE_DIRINFO : NO_DIRINFO));
  895. ds = router_get_trusteddirserver_by_digest(digest);
  896. if (!ds) {
  897. ds = trusted_dir_server_new(options->Nickname, NULL,
  898. router_get_advertised_dir_port(options, 0),
  899. router_get_advertised_or_port(options),
  900. digest,
  901. v3_digest,
  902. type, 0.0);
  903. if (!ds) {
  904. log_err(LD_GENERAL,"We want to be a directory authority, but we "
  905. "couldn't add ourselves to the authority list. Failing.");
  906. return -1;
  907. }
  908. dir_server_add(ds);
  909. }
  910. if (ds->type != type) {
  911. log_warn(LD_DIR, "Configured authority type does not match authority "
  912. "type in DirAuthority list. Adjusting. (%d v %d)",
  913. type, ds->type);
  914. ds->type = type;
  915. }
  916. if (v3_digest_set && (ds->type & V3_DIRINFO) &&
  917. tor_memneq(v3_digest, ds->v3_identity_digest, DIGEST_LEN)) {
  918. log_warn(LD_DIR, "V3 identity key does not match identity declared in "
  919. "DirAuthority line. Adjusting.");
  920. memcpy(ds->v3_identity_digest, v3_digest, DIGEST_LEN);
  921. }
  922. if (cert) { /* add my own cert to the list of known certs */
  923. log_info(LD_DIR, "adding my own v3 cert");
  924. if (trusted_dirs_load_certs_from_string(
  925. cert->cache_info.signed_descriptor_body,
  926. TRUSTED_DIRS_CERTS_SRC_SELF, 0)<0) {
  927. log_warn(LD_DIR, "Unable to parse my own v3 cert! Failing.");
  928. return -1;
  929. }
  930. }
  931. return 0; /* success */
  932. }
  933. /* Keep track of whether we should upload our server descriptor,
  934. * and what type of server we are.
  935. */
  936. /** Whether we can reach our ORPort from the outside. */
  937. static int can_reach_or_port = 0;
  938. /** Whether we can reach our DirPort from the outside. */
  939. static int can_reach_dir_port = 0;
  940. /** Forget what we have learned about our reachability status. */
  941. void
  942. router_reset_reachability(void)
  943. {
  944. can_reach_or_port = can_reach_dir_port = 0;
  945. }
  946. /** Return 1 if ORPort is known reachable; else return 0. */
  947. int
  948. check_whether_orport_reachable(void)
  949. {
  950. const or_options_t *options = get_options();
  951. return options->AssumeReachable ||
  952. can_reach_or_port;
  953. }
  954. /** Return 1 if we don't have a dirport configured, or if it's reachable. */
  955. int
  956. check_whether_dirport_reachable(void)
  957. {
  958. const or_options_t *options = get_options();
  959. return !options->DirPort_set ||
  960. options->AssumeReachable ||
  961. net_is_disabled() ||
  962. can_reach_dir_port;
  963. }
  964. /** Look at a variety of factors, and return 0 if we don't want to
  965. * advertise the fact that we have a DirPort open. Else return the
  966. * DirPort we want to advertise.
  967. *
  968. * Log a helpful message if we change our mind about whether to publish
  969. * a DirPort.
  970. */
  971. static int
  972. decide_to_advertise_dirport(const or_options_t *options, uint16_t dir_port)
  973. {
  974. static int advertising=1; /* start out assuming we will advertise */
  975. int new_choice=1;
  976. const char *reason = NULL;
  977. /* Section one: reasons to publish or not publish that aren't
  978. * worth mentioning to the user, either because they're obvious
  979. * or because they're normal behavior. */
  980. if (!dir_port) /* short circuit the rest of the function */
  981. return 0;
  982. if (authdir_mode(options)) /* always publish */
  983. return dir_port;
  984. if (net_is_disabled())
  985. return 0;
  986. if (!check_whether_dirport_reachable())
  987. return 0;
  988. if (!router_get_advertised_dir_port(options, dir_port))
  989. return 0;
  990. /* Section two: reasons to publish or not publish that the user
  991. * might find surprising. These are generally config options that
  992. * make us choose not to publish. */
  993. if (accounting_is_enabled(options)) {
  994. /* Don't spend bytes for directory traffic if we could end up hibernating,
  995. * but allow DirPort otherwise. Some people set AccountingMax because
  996. * they're confused or to get statistics. */
  997. int interval_length = accounting_get_interval_length();
  998. uint32_t effective_bw = get_effective_bwrate(options);
  999. if (!interval_length) {
  1000. log_warn(LD_BUG, "An accounting interval is not allowed to be zero "
  1001. "seconds long. Raising to 1.");
  1002. interval_length = 1;
  1003. }
  1004. log_info(LD_GENERAL, "Calculating whether to disable dirport: effective "
  1005. "bwrate: %u, AccountingMax: "U64_FORMAT", "
  1006. "accounting interval length %d", effective_bw,
  1007. U64_PRINTF_ARG(options->AccountingMax),
  1008. interval_length);
  1009. if (effective_bw >=
  1010. options->AccountingMax / interval_length) {
  1011. new_choice = 0;
  1012. reason = "AccountingMax enabled";
  1013. }
  1014. #define MIN_BW_TO_ADVERTISE_DIRPORT 51200
  1015. } else if (options->BandwidthRate < MIN_BW_TO_ADVERTISE_DIRPORT ||
  1016. (options->RelayBandwidthRate > 0 &&
  1017. options->RelayBandwidthRate < MIN_BW_TO_ADVERTISE_DIRPORT)) {
  1018. /* if we're advertising a small amount */
  1019. new_choice = 0;
  1020. reason = "BandwidthRate under 50KB";
  1021. }
  1022. if (advertising != new_choice) {
  1023. if (new_choice == 1) {
  1024. log_notice(LD_DIR, "Advertising DirPort as %d", dir_port);
  1025. } else {
  1026. tor_assert(reason);
  1027. log_notice(LD_DIR, "Not advertising DirPort (Reason: %s)", reason);
  1028. }
  1029. advertising = new_choice;
  1030. }
  1031. return advertising ? dir_port : 0;
  1032. }
  1033. /** Allocate and return a new extend_info_t that can be used to build
  1034. * a circuit to or through the router <b>r</b>. Use the primary
  1035. * address of the router unless <b>for_direct_connect</b> is true, in
  1036. * which case the preferred address is used instead. */
  1037. static extend_info_t *
  1038. extend_info_from_router(const routerinfo_t *r)
  1039. {
  1040. tor_addr_port_t ap;
  1041. tor_assert(r);
  1042. router_get_prim_orport(r, &ap);
  1043. return extend_info_new(r->nickname, r->cache_info.identity_digest,
  1044. r->onion_pkey, r->onion_curve25519_pkey,
  1045. &ap.addr, ap.port);
  1046. }
  1047. /** Some time has passed, or we just got new directory information.
  1048. * See if we currently believe our ORPort or DirPort to be
  1049. * unreachable. If so, launch a new test for it.
  1050. *
  1051. * For ORPort, we simply try making a circuit that ends at ourselves.
  1052. * Success is noticed in onionskin_answer().
  1053. *
  1054. * For DirPort, we make a connection via Tor to our DirPort and ask
  1055. * for our own server descriptor.
  1056. * Success is noticed in connection_dir_client_reached_eof().
  1057. */
  1058. void
  1059. consider_testing_reachability(int test_or, int test_dir)
  1060. {
  1061. const routerinfo_t *me = router_get_my_routerinfo();
  1062. int orport_reachable = check_whether_orport_reachable();
  1063. tor_addr_t addr;
  1064. const or_options_t *options = get_options();
  1065. if (!me)
  1066. return;
  1067. if (routerset_contains_router(options->ExcludeNodes, me, -1) &&
  1068. options->StrictNodes) {
  1069. /* If we've excluded ourself, and StrictNodes is set, we can't test
  1070. * ourself. */
  1071. if (test_or || test_dir) {
  1072. #define SELF_EXCLUDED_WARN_INTERVAL 3600
  1073. static ratelim_t warning_limit=RATELIM_INIT(SELF_EXCLUDED_WARN_INTERVAL);
  1074. log_fn_ratelim(&warning_limit, LOG_WARN, LD_CIRC,
  1075. "Can't peform self-tests for this relay: we have "
  1076. "listed ourself in ExcludeNodes, and StrictNodes is set. "
  1077. "We cannot learn whether we are usable, and will not "
  1078. "be able to advertise ourself.");
  1079. }
  1080. return;
  1081. }
  1082. if (test_or && (!orport_reachable || !circuit_enough_testing_circs())) {
  1083. extend_info_t *ei = extend_info_from_router(me);
  1084. /* XXX IPv6 self testing */
  1085. log_info(LD_CIRC, "Testing %s of my ORPort: %s:%d.",
  1086. !orport_reachable ? "reachability" : "bandwidth",
  1087. fmt_addr32(me->addr), me->or_port);
  1088. circuit_launch_by_extend_info(CIRCUIT_PURPOSE_TESTING, ei,
  1089. CIRCLAUNCH_NEED_CAPACITY|CIRCLAUNCH_IS_INTERNAL);
  1090. extend_info_free(ei);
  1091. }
  1092. tor_addr_from_ipv4h(&addr, me->addr);
  1093. if (test_dir && !check_whether_dirport_reachable() &&
  1094. !connection_get_by_type_addr_port_purpose(
  1095. CONN_TYPE_DIR, &addr, me->dir_port,
  1096. DIR_PURPOSE_FETCH_SERVERDESC)) {
  1097. /* ask myself, via tor, for my server descriptor. */
  1098. directory_initiate_command(&addr,
  1099. me->or_port, me->dir_port,
  1100. me->cache_info.identity_digest,
  1101. DIR_PURPOSE_FETCH_SERVERDESC,
  1102. ROUTER_PURPOSE_GENERAL,
  1103. DIRIND_ANON_DIRPORT, "authority.z", NULL, 0, 0);
  1104. }
  1105. }
  1106. /** Annotate that we found our ORPort reachable. */
  1107. void
  1108. router_orport_found_reachable(void)
  1109. {
  1110. const routerinfo_t *me = router_get_my_routerinfo();
  1111. if (!can_reach_or_port && me) {
  1112. char *address = tor_dup_ip(me->addr);
  1113. log_notice(LD_OR,"Self-testing indicates your ORPort is reachable from "
  1114. "the outside. Excellent.%s",
  1115. get_options()->PublishServerDescriptor_ != NO_DIRINFO ?
  1116. " Publishing server descriptor." : "");
  1117. can_reach_or_port = 1;
  1118. mark_my_descriptor_dirty("ORPort found reachable");
  1119. control_event_server_status(LOG_NOTICE,
  1120. "REACHABILITY_SUCCEEDED ORADDRESS=%s:%d",
  1121. address, me->or_port);
  1122. tor_free(address);
  1123. }
  1124. }
  1125. /** Annotate that we found our DirPort reachable. */
  1126. void
  1127. router_dirport_found_reachable(void)
  1128. {
  1129. const routerinfo_t *me = router_get_my_routerinfo();
  1130. if (!can_reach_dir_port && me) {
  1131. char *address = tor_dup_ip(me->addr);
  1132. log_notice(LD_DIRSERV,"Self-testing indicates your DirPort is reachable "
  1133. "from the outside. Excellent.");
  1134. can_reach_dir_port = 1;
  1135. if (decide_to_advertise_dirport(get_options(), me->dir_port))
  1136. mark_my_descriptor_dirty("DirPort found reachable");
  1137. control_event_server_status(LOG_NOTICE,
  1138. "REACHABILITY_SUCCEEDED DIRADDRESS=%s:%d",
  1139. address, me->dir_port);
  1140. tor_free(address);
  1141. }
  1142. }
  1143. /** We have enough testing circuits open. Send a bunch of "drop"
  1144. * cells down each of them, to exercise our bandwidth. */
  1145. void
  1146. router_perform_bandwidth_test(int num_circs, time_t now)
  1147. {
  1148. int num_cells = (int)(get_options()->BandwidthRate * 10 /
  1149. CELL_MAX_NETWORK_SIZE);
  1150. int max_cells = num_cells < CIRCWINDOW_START ?
  1151. num_cells : CIRCWINDOW_START;
  1152. int cells_per_circuit = max_cells / num_circs;
  1153. origin_circuit_t *circ = NULL;
  1154. log_notice(LD_OR,"Performing bandwidth self-test...done.");
  1155. while ((circ = circuit_get_next_by_pk_and_purpose(circ, NULL,
  1156. CIRCUIT_PURPOSE_TESTING))) {
  1157. /* dump cells_per_circuit drop cells onto this circ */
  1158. int i = cells_per_circuit;
  1159. if (circ->base_.state != CIRCUIT_STATE_OPEN)
  1160. continue;
  1161. circ->base_.timestamp_dirty = now;
  1162. while (i-- > 0) {
  1163. if (relay_send_command_from_edge(0, TO_CIRCUIT(circ),
  1164. RELAY_COMMAND_DROP,
  1165. NULL, 0, circ->cpath->prev)<0) {
  1166. return; /* stop if error */
  1167. }
  1168. }
  1169. }
  1170. }
  1171. /** Return true iff our network is in some sense disabled: either we're
  1172. * hibernating, entering hibernation, or the network is turned off with
  1173. * DisableNetwork. */
  1174. int
  1175. net_is_disabled(void)
  1176. {
  1177. return get_options()->DisableNetwork || we_are_hibernating();
  1178. }
  1179. /** Return true iff we believe ourselves to be an authoritative
  1180. * directory server.
  1181. */
  1182. int
  1183. authdir_mode(const or_options_t *options)
  1184. {
  1185. return options->AuthoritativeDir != 0;
  1186. }
  1187. /** Return true iff we believe ourselves to be a v3 authoritative
  1188. * directory server.
  1189. */
  1190. int
  1191. authdir_mode_v3(const or_options_t *options)
  1192. {
  1193. return authdir_mode(options) && options->V3AuthoritativeDir != 0;
  1194. }
  1195. /** Return true iff we are a v3 directory authority. */
  1196. int
  1197. authdir_mode_any_main(const or_options_t *options)
  1198. {
  1199. return options->V3AuthoritativeDir;
  1200. }
  1201. /** Return true if we believe ourselves to be any kind of
  1202. * authoritative directory beyond just a hidserv authority. */
  1203. int
  1204. authdir_mode_any_nonhidserv(const or_options_t *options)
  1205. {
  1206. return options->BridgeAuthoritativeDir ||
  1207. authdir_mode_any_main(options);
  1208. }
  1209. /** Return true iff we are an authoritative directory server that is
  1210. * authoritative about receiving and serving descriptors of type
  1211. * <b>purpose</b> on its dirport. Use -1 for "any purpose". */
  1212. int
  1213. authdir_mode_handles_descs(const or_options_t *options, int purpose)
  1214. {
  1215. if (purpose < 0)
  1216. return authdir_mode_any_nonhidserv(options);
  1217. else if (purpose == ROUTER_PURPOSE_GENERAL)
  1218. return authdir_mode_any_main(options);
  1219. else if (purpose == ROUTER_PURPOSE_BRIDGE)
  1220. return (options->BridgeAuthoritativeDir);
  1221. else
  1222. return 0;
  1223. }
  1224. /** Return true iff we are an authoritative directory server that
  1225. * publishes its own network statuses.
  1226. */
  1227. int
  1228. authdir_mode_publishes_statuses(const or_options_t *options)
  1229. {
  1230. if (authdir_mode_bridge(options))
  1231. return 0;
  1232. return authdir_mode_any_nonhidserv(options);
  1233. }
  1234. /** Return true iff we are an authoritative directory server that
  1235. * tests reachability of the descriptors it learns about.
  1236. */
  1237. int
  1238. authdir_mode_tests_reachability(const or_options_t *options)
  1239. {
  1240. return authdir_mode_handles_descs(options, -1);
  1241. }
  1242. /** Return true iff we believe ourselves to be a bridge authoritative
  1243. * directory server.
  1244. */
  1245. int
  1246. authdir_mode_bridge(const or_options_t *options)
  1247. {
  1248. return authdir_mode(options) && options->BridgeAuthoritativeDir != 0;
  1249. }
  1250. /** Return true iff we are trying to be a server.
  1251. */
  1252. MOCK_IMPL(int,
  1253. server_mode,(const or_options_t *options))
  1254. {
  1255. if (options->ClientOnly) return 0;
  1256. /* XXXX024 I believe we can kill off ORListenAddress here.*/
  1257. return (options->ORPort_set || options->ORListenAddress);
  1258. }
  1259. /** Return true iff we are trying to be a non-bridge server.
  1260. */
  1261. MOCK_IMPL(int,
  1262. public_server_mode,(const or_options_t *options))
  1263. {
  1264. if (!server_mode(options)) return 0;
  1265. return (!options->BridgeRelay);
  1266. }
  1267. /** Return true iff the combination of options in <b>options</b> and parameters
  1268. * in the consensus mean that we don't want to allow exits from circuits
  1269. * we got from addresses not known to be servers. */
  1270. int
  1271. should_refuse_unknown_exits(const or_options_t *options)
  1272. {
  1273. if (options->RefuseUnknownExits != -1) {
  1274. return options->RefuseUnknownExits;
  1275. } else {
  1276. return networkstatus_get_param(NULL, "refuseunknownexits", 1, 0, 1);
  1277. }
  1278. }
  1279. /** Remember if we've advertised ourselves to the dirservers. */
  1280. static int server_is_advertised=0;
  1281. /** Return true iff we have published our descriptor lately.
  1282. */
  1283. int
  1284. advertised_server_mode(void)
  1285. {
  1286. return server_is_advertised;
  1287. }
  1288. /**
  1289. * Called with a boolean: set whether we have recently published our
  1290. * descriptor.
  1291. */
  1292. static void
  1293. set_server_advertised(int s)
  1294. {
  1295. server_is_advertised = s;
  1296. }
  1297. /** Return true iff we are trying to proxy client connections. */
  1298. int
  1299. proxy_mode(const or_options_t *options)
  1300. {
  1301. (void)options;
  1302. SMARTLIST_FOREACH_BEGIN(get_configured_ports(), const port_cfg_t *, p) {
  1303. if (p->type == CONN_TYPE_AP_LISTENER ||
  1304. p->type == CONN_TYPE_AP_TRANS_LISTENER ||
  1305. p->type == CONN_TYPE_AP_DNS_LISTENER ||
  1306. p->type == CONN_TYPE_AP_NATD_LISTENER)
  1307. return 1;
  1308. } SMARTLIST_FOREACH_END(p);
  1309. return 0;
  1310. }
  1311. /** Decide if we're a publishable server. We are a publishable server if:
  1312. * - We don't have the ClientOnly option set
  1313. * and
  1314. * - We have the PublishServerDescriptor option set to non-empty
  1315. * and
  1316. * - We have ORPort set
  1317. * and
  1318. * - We believe we are reachable from the outside; or
  1319. * - We are an authoritative directory server.
  1320. */
  1321. static int
  1322. decide_if_publishable_server(void)
  1323. {
  1324. const or_options_t *options = get_options();
  1325. if (options->ClientOnly)
  1326. return 0;
  1327. if (options->PublishServerDescriptor_ == NO_DIRINFO)
  1328. return 0;
  1329. if (!server_mode(options))
  1330. return 0;
  1331. if (authdir_mode(options))
  1332. return 1;
  1333. if (!router_get_advertised_or_port(options))
  1334. return 0;
  1335. return check_whether_orport_reachable();
  1336. }
  1337. /** Initiate server descriptor upload as reasonable (if server is publishable,
  1338. * etc). <b>force</b> is as for router_upload_dir_desc_to_dirservers.
  1339. *
  1340. * We need to rebuild the descriptor if it's dirty even if we're not
  1341. * uploading, because our reachability testing *uses* our descriptor to
  1342. * determine what IP address and ports to test.
  1343. */
  1344. void
  1345. consider_publishable_server(int force)
  1346. {
  1347. int rebuilt;
  1348. if (!server_mode(get_options()))
  1349. return;
  1350. rebuilt = router_rebuild_descriptor(0);
  1351. if (decide_if_publishable_server()) {
  1352. set_server_advertised(1);
  1353. if (rebuilt == 0)
  1354. router_upload_dir_desc_to_dirservers(force);
  1355. } else {
  1356. set_server_advertised(0);
  1357. }
  1358. }
  1359. /** Return the port of the first active listener of type
  1360. * <b>listener_type</b>. */
  1361. /** XXX not a very good interface. it's not reliable when there are
  1362. multiple listeners. */
  1363. uint16_t
  1364. router_get_active_listener_port_by_type_af(int listener_type,
  1365. sa_family_t family)
  1366. {
  1367. /* Iterate all connections, find one of the right kind and return
  1368. the port. Not very sophisticated or fast, but effective. */
  1369. smartlist_t *conns = get_connection_array();
  1370. SMARTLIST_FOREACH_BEGIN(conns, connection_t *, conn) {
  1371. if (conn->type == listener_type && !conn->marked_for_close &&
  1372. conn->socket_family == family) {
  1373. return conn->port;
  1374. }
  1375. } SMARTLIST_FOREACH_END(conn);
  1376. return 0;
  1377. }
  1378. /** Return the port that we should advertise as our ORPort; this is either
  1379. * the one configured in the ORPort option, or the one we actually bound to
  1380. * if ORPort is "auto".
  1381. */
  1382. uint16_t
  1383. router_get_advertised_or_port(const or_options_t *options)
  1384. {
  1385. return router_get_advertised_or_port_by_af(options, AF_INET);
  1386. }
  1387. /** As router_get_advertised_or_port(), but allows an address family argument.
  1388. */
  1389. uint16_t
  1390. router_get_advertised_or_port_by_af(const or_options_t *options,
  1391. sa_family_t family)
  1392. {
  1393. int port = get_first_advertised_port_by_type_af(CONN_TYPE_OR_LISTENER,
  1394. family);
  1395. (void)options;
  1396. /* If the port is in 'auto' mode, we have to use
  1397. router_get_listener_port_by_type(). */
  1398. if (port == CFG_AUTO_PORT)
  1399. return router_get_active_listener_port_by_type_af(CONN_TYPE_OR_LISTENER,
  1400. family);
  1401. return port;
  1402. }
  1403. /** Return the port that we should advertise as our DirPort;
  1404. * this is one of three possibilities:
  1405. * The one that is passed as <b>dirport</b> if the DirPort option is 0, or
  1406. * the one configured in the DirPort option,
  1407. * or the one we actually bound to if DirPort is "auto". */
  1408. uint16_t
  1409. router_get_advertised_dir_port(const or_options_t *options, uint16_t dirport)
  1410. {
  1411. int dirport_configured = get_primary_dir_port();
  1412. (void)options;
  1413. if (!dirport_configured)
  1414. return dirport;
  1415. if (dirport_configured == CFG_AUTO_PORT)
  1416. return router_get_active_listener_port_by_type_af(CONN_TYPE_DIR_LISTENER,
  1417. AF_INET);
  1418. return dirport_configured;
  1419. }
  1420. /*
  1421. * OR descriptor generation.
  1422. */
  1423. /** My routerinfo. */
  1424. static routerinfo_t *desc_routerinfo = NULL;
  1425. /** My extrainfo */
  1426. static extrainfo_t *desc_extrainfo = NULL;
  1427. /** Why did we most recently decide to regenerate our descriptor? Used to
  1428. * tell the authorities why we're sending it to them. */
  1429. static const char *desc_gen_reason = NULL;
  1430. /** Since when has our descriptor been "clean"? 0 if we need to regenerate it
  1431. * now. */
  1432. static time_t desc_clean_since = 0;
  1433. /** Why did we mark the descriptor dirty? */
  1434. static const char *desc_dirty_reason = NULL;
  1435. /** Boolean: do we need to regenerate the above? */
  1436. static int desc_needs_upload = 0;
  1437. /** OR only: If <b>force</b> is true, or we haven't uploaded this
  1438. * descriptor successfully yet, try to upload our signed descriptor to
  1439. * all the directory servers we know about.
  1440. */
  1441. void
  1442. router_upload_dir_desc_to_dirservers(int force)
  1443. {
  1444. const routerinfo_t *ri;
  1445. extrainfo_t *ei;
  1446. char *msg;
  1447. size_t desc_len, extra_len = 0, total_len;
  1448. dirinfo_type_t auth = get_options()->PublishServerDescriptor_;
  1449. ri = router_get_my_routerinfo();
  1450. if (!ri) {
  1451. log_info(LD_GENERAL, "No descriptor; skipping upload");
  1452. return;
  1453. }
  1454. ei = router_get_my_extrainfo();
  1455. if (auth == NO_DIRINFO)
  1456. return;
  1457. if (!force && !desc_needs_upload)
  1458. return;
  1459. log_info(LD_OR, "Uploading relay descriptor to directory authorities%s",
  1460. force ? " (forced)" : "");
  1461. desc_needs_upload = 0;
  1462. desc_len = ri->cache_info.signed_descriptor_len;
  1463. extra_len = ei ? ei->cache_info.signed_descriptor_len : 0;
  1464. total_len = desc_len + extra_len + 1;
  1465. msg = tor_malloc(total_len);
  1466. memcpy(msg, ri->cache_info.signed_descriptor_body, desc_len);
  1467. if (ei) {
  1468. memcpy(msg+desc_len, ei->cache_info.signed_descriptor_body, extra_len);
  1469. }
  1470. msg[desc_len+extra_len] = 0;
  1471. directory_post_to_dirservers(DIR_PURPOSE_UPLOAD_DIR,
  1472. (auth & BRIDGE_DIRINFO) ?
  1473. ROUTER_PURPOSE_BRIDGE :
  1474. ROUTER_PURPOSE_GENERAL,
  1475. auth, msg, desc_len, extra_len);
  1476. tor_free(msg);
  1477. }
  1478. /** OR only: Check whether my exit policy says to allow connection to
  1479. * conn. Return 0 if we accept; non-0 if we reject.
  1480. */
  1481. int
  1482. router_compare_to_my_exit_policy(const tor_addr_t *addr, uint16_t port)
  1483. {
  1484. if (!router_get_my_routerinfo()) /* make sure desc_routerinfo exists */
  1485. return -1;
  1486. /* make sure it's resolved to something. this way we can't get a
  1487. 'maybe' below. */
  1488. if (tor_addr_is_null(addr))
  1489. return -1;
  1490. /* look at desc_routerinfo->exit_policy for both the v4 and the v6
  1491. * policies. The exit_policy field in desc_routerinfo is a bit unusual,
  1492. * in that it contains IPv6 and IPv6 entries. We don't want to look
  1493. * at desc_routerinfio->ipv6_exit_policy, since that's a port summary. */
  1494. if ((tor_addr_family(addr) == AF_INET ||
  1495. tor_addr_family(addr) == AF_INET6)) {
  1496. return compare_tor_addr_to_addr_policy(addr, port,
  1497. desc_routerinfo->exit_policy) != ADDR_POLICY_ACCEPTED;
  1498. #if 0
  1499. } else if (tor_addr_family(addr) == AF_INET6) {
  1500. return get_options()->IPv6Exit &&
  1501. desc_routerinfo->ipv6_exit_policy &&
  1502. compare_tor_addr_to_short_policy(addr, port,
  1503. desc_routerinfo->ipv6_exit_policy) != ADDR_POLICY_ACCEPTED;
  1504. #endif
  1505. } else {
  1506. return -1;
  1507. }
  1508. }
  1509. /** Return true iff my exit policy is reject *:*. Return -1 if we don't
  1510. * have a descriptor */
  1511. int
  1512. router_my_exit_policy_is_reject_star(void)
  1513. {
  1514. if (!router_get_my_routerinfo()) /* make sure desc_routerinfo exists */
  1515. return -1;
  1516. return desc_routerinfo->policy_is_reject_star;
  1517. }
  1518. /** Return true iff I'm a server and <b>digest</b> is equal to
  1519. * my server identity key digest. */
  1520. int
  1521. router_digest_is_me(const char *digest)
  1522. {
  1523. return (server_identitykey &&
  1524. tor_memeq(server_identitykey_digest, digest, DIGEST_LEN));
  1525. }
  1526. /** Return my identity digest. */
  1527. const uint8_t *
  1528. router_get_my_id_digest(void)
  1529. {
  1530. return (const uint8_t *)server_identitykey_digest;
  1531. }
  1532. /** Return true iff I'm a server and <b>digest</b> is equal to
  1533. * my identity digest. */
  1534. int
  1535. router_extrainfo_digest_is_me(const char *digest)
  1536. {
  1537. extrainfo_t *ei = router_get_my_extrainfo();
  1538. if (!ei)
  1539. return 0;
  1540. return tor_memeq(digest,
  1541. ei->cache_info.signed_descriptor_digest,
  1542. DIGEST_LEN);
  1543. }
  1544. /** A wrapper around router_digest_is_me(). */
  1545. int
  1546. router_is_me(const routerinfo_t *router)
  1547. {
  1548. return router_digest_is_me(router->cache_info.identity_digest);
  1549. }
  1550. /** Return a routerinfo for this OR, rebuilding a fresh one if
  1551. * necessary. Return NULL on error, or if called on an OP. */
  1552. MOCK_IMPL(const routerinfo_t *,
  1553. router_get_my_routerinfo,(void))
  1554. {
  1555. if (!server_mode(get_options()))
  1556. return NULL;
  1557. if (router_rebuild_descriptor(0))
  1558. return NULL;
  1559. return desc_routerinfo;
  1560. }
  1561. /** OR only: Return a signed server descriptor for this OR, rebuilding a fresh
  1562. * one if necessary. Return NULL on error.
  1563. */
  1564. const char *
  1565. router_get_my_descriptor(void)
  1566. {
  1567. const char *body;
  1568. if (!router_get_my_routerinfo())
  1569. return NULL;
  1570. /* Make sure this is nul-terminated. */
  1571. tor_assert(desc_routerinfo->cache_info.saved_location == SAVED_NOWHERE);
  1572. body = signed_descriptor_get_body(&desc_routerinfo->cache_info);
  1573. tor_assert(!body[desc_routerinfo->cache_info.signed_descriptor_len]);
  1574. log_debug(LD_GENERAL,"my desc is '%s'", body);
  1575. return body;
  1576. }
  1577. /** Return the extrainfo document for this OR, or NULL if we have none.
  1578. * Rebuilt it (and the server descriptor) if necessary. */
  1579. extrainfo_t *
  1580. router_get_my_extrainfo(void)
  1581. {
  1582. if (!server_mode(get_options()))
  1583. return NULL;
  1584. if (router_rebuild_descriptor(0))
  1585. return NULL;
  1586. return desc_extrainfo;
  1587. }
  1588. /** Return a human-readable string describing what triggered us to generate
  1589. * our current descriptor, or NULL if we don't know. */
  1590. const char *
  1591. router_get_descriptor_gen_reason(void)
  1592. {
  1593. return desc_gen_reason;
  1594. }
  1595. /** A list of nicknames that we've warned about including in our family
  1596. * declaration verbatim rather than as digests. */
  1597. static smartlist_t *warned_nonexistent_family = NULL;
  1598. static int router_guess_address_from_dir_headers(uint32_t *guess);
  1599. /** Make a current best guess at our address, either because
  1600. * it's configured in torrc, or because we've learned it from
  1601. * dirserver headers. Place the answer in *<b>addr</b> and return
  1602. * 0 on success, else return -1 if we have no guess. */
  1603. int
  1604. router_pick_published_address(const or_options_t *options, uint32_t *addr)
  1605. {
  1606. *addr = get_last_resolved_addr();
  1607. if (!*addr &&
  1608. resolve_my_address(LOG_INFO, options, addr, NULL, NULL) < 0) {
  1609. log_info(LD_CONFIG, "Could not determine our address locally. "
  1610. "Checking if directory headers provide any hints.");
  1611. if (router_guess_address_from_dir_headers(addr) < 0) {
  1612. log_info(LD_CONFIG, "No hints from directory headers either. "
  1613. "Will try again later.");
  1614. return -1;
  1615. }
  1616. }
  1617. log_info(LD_CONFIG,"Success: chose address '%s'.", fmt_addr32(*addr));
  1618. return 0;
  1619. }
  1620. /** If <b>force</b> is true, or our descriptor is out-of-date, rebuild a fresh
  1621. * routerinfo, signed server descriptor, and extra-info document for this OR.
  1622. * Return 0 on success, -1 on temporary error.
  1623. */
  1624. int
  1625. router_rebuild_descriptor(int force)
  1626. {
  1627. routerinfo_t *ri;
  1628. extrainfo_t *ei;
  1629. uint32_t addr;
  1630. char platform[256];
  1631. int hibernating = we_are_hibernating();
  1632. const or_options_t *options = get_options();
  1633. if (desc_clean_since && !force)
  1634. return 0;
  1635. if (router_pick_published_address(options, &addr) < 0 ||
  1636. router_get_advertised_or_port(options) == 0) {
  1637. /* Stop trying to rebuild our descriptor every second. We'll
  1638. * learn that it's time to try again when ip_address_changed()
  1639. * marks it dirty. */
  1640. desc_clean_since = time(NULL);
  1641. return -1;
  1642. }
  1643. log_info(LD_OR, "Rebuilding relay descriptor%s", force ? " (forced)" : "");
  1644. ri = tor_malloc_zero(sizeof(routerinfo_t));
  1645. ri->cache_info.routerlist_index = -1;
  1646. ri->nickname = tor_strdup(options->Nickname);
  1647. ri->addr = addr;
  1648. ri->or_port = router_get_advertised_or_port(options);
  1649. ri->dir_port = router_get_advertised_dir_port(options, 0);
  1650. ri->cache_info.published_on = time(NULL);
  1651. ri->onion_pkey = crypto_pk_dup_key(get_onion_key()); /* must invoke from
  1652. * main thread */
  1653. #ifdef CURVE25519_ENABLED
  1654. ri->onion_curve25519_pkey =
  1655. tor_memdup(&get_current_curve25519_keypair()->pubkey,
  1656. sizeof(curve25519_public_key_t));
  1657. #endif
  1658. /* For now, at most one IPv6 or-address is being advertised. */
  1659. {
  1660. const port_cfg_t *ipv6_orport = NULL;
  1661. SMARTLIST_FOREACH_BEGIN(get_configured_ports(), const port_cfg_t *, p) {
  1662. if (p->type == CONN_TYPE_OR_LISTENER &&
  1663. ! p->no_advertise &&
  1664. ! p->bind_ipv4_only &&
  1665. tor_addr_family(&p->addr) == AF_INET6) {
  1666. if (! tor_addr_is_internal(&p->addr, 0)) {
  1667. ipv6_orport = p;
  1668. break;
  1669. } else {
  1670. char addrbuf[TOR_ADDR_BUF_LEN];
  1671. log_warn(LD_CONFIG,
  1672. "Unable to use configured IPv6 address \"%s\" in a "
  1673. "descriptor. Skipping it. "
  1674. "Try specifying a globally reachable address explicitly. ",
  1675. tor_addr_to_str(addrbuf, &p->addr, sizeof(addrbuf), 1));
  1676. }
  1677. }
  1678. } SMARTLIST_FOREACH_END(p);
  1679. if (ipv6_orport) {
  1680. tor_addr_copy(&ri->ipv6_addr, &ipv6_orport->addr);
  1681. ri->ipv6_orport = ipv6_orport->port;
  1682. }
  1683. }
  1684. ri->identity_pkey = crypto_pk_dup_key(get_server_identity_key());
  1685. if (crypto_pk_get_digest(ri->identity_pkey,
  1686. ri->cache_info.identity_digest)<0) {
  1687. routerinfo_free(ri);
  1688. return -1;
  1689. }
  1690. get_platform_str(platform, sizeof(platform));
  1691. ri->platform = tor_strdup(platform);
  1692. /* compute ri->bandwidthrate as the min of various options */
  1693. ri->bandwidthrate = get_effective_bwrate(options);
  1694. /* and compute ri->bandwidthburst similarly */
  1695. ri->bandwidthburst = get_effective_bwburst(options);
  1696. ri->bandwidthcapacity = hibernating ? 0 : rep_hist_bandwidth_assess();
  1697. if (dns_seems_to_be_broken() || has_dns_init_failed()) {
  1698. /* DNS is screwed up; don't claim to be an exit. */
  1699. policies_exit_policy_append_reject_star(&ri->exit_policy);
  1700. } else {
  1701. policies_parse_exit_policy(options->ExitPolicy, &ri->exit_policy,
  1702. options->IPv6Exit,
  1703. options->ExitPolicyRejectPrivate,
  1704. ri->addr, !options->BridgeRelay);
  1705. }
  1706. ri->policy_is_reject_star =
  1707. policy_is_reject_star(ri->exit_policy, AF_INET) &&
  1708. policy_is_reject_star(ri->exit_policy, AF_INET6);
  1709. if (options->IPv6Exit) {
  1710. char *p_tmp = policy_summarize(ri->exit_policy, AF_INET6);
  1711. if (p_tmp)
  1712. ri->ipv6_exit_policy = parse_short_policy(p_tmp);
  1713. tor_free(p_tmp);
  1714. }
  1715. if (options->MyFamily && ! options->BridgeRelay) {
  1716. smartlist_t *family;
  1717. if (!warned_nonexistent_family)
  1718. warned_nonexistent_family = smartlist_new();
  1719. family = smartlist_new();
  1720. ri->declared_family = smartlist_new();
  1721. smartlist_split_string(family, options->MyFamily, ",",
  1722. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK|SPLIT_STRIP_SPACE, 0);
  1723. SMARTLIST_FOREACH_BEGIN(family, char *, name) {
  1724. const node_t *member;
  1725. if (!strcasecmp(name, options->Nickname))
  1726. goto skip; /* Don't list ourself, that's redundant */
  1727. else
  1728. member = node_get_by_nickname(name, 1);
  1729. if (!member) {
  1730. int is_legal = is_legal_nickname_or_hexdigest(name);
  1731. if (!smartlist_contains_string(warned_nonexistent_family, name) &&
  1732. !is_legal_hexdigest(name)) {
  1733. if (is_legal)
  1734. log_warn(LD_CONFIG,
  1735. "I have no descriptor for the router named \"%s\" in my "
  1736. "declared family; I'll use the nickname as is, but "
  1737. "this may confuse clients.", name);
  1738. else
  1739. log_warn(LD_CONFIG, "There is a router named \"%s\" in my "
  1740. "declared family, but that isn't a legal nickname. "
  1741. "Skipping it.", escaped(name));
  1742. smartlist_add(warned_nonexistent_family, tor_strdup(name));
  1743. }
  1744. if (is_legal) {
  1745. smartlist_add(ri->declared_family, name);
  1746. name = NULL;
  1747. }
  1748. } else if (router_digest_is_me(member->identity)) {
  1749. /* Don't list ourself in our own family; that's redundant */
  1750. /* XXX shouldn't be possible */
  1751. } else {
  1752. char *fp = tor_malloc(HEX_DIGEST_LEN+2);
  1753. fp[0] = '$';
  1754. base16_encode(fp+1,HEX_DIGEST_LEN+1,
  1755. member->identity, DIGEST_LEN);
  1756. smartlist_add(ri->declared_family, fp);
  1757. if (smartlist_contains_string(warned_nonexistent_family, name))
  1758. smartlist_string_remove(warned_nonexistent_family, name);
  1759. }
  1760. skip:
  1761. tor_free(name);
  1762. } SMARTLIST_FOREACH_END(name);
  1763. /* remove duplicates from the list */
  1764. smartlist_sort_strings(ri->declared_family);
  1765. smartlist_uniq_strings(ri->declared_family);
  1766. smartlist_free(family);
  1767. }
  1768. /* Now generate the extrainfo. */
  1769. ei = tor_malloc_zero(sizeof(extrainfo_t));
  1770. ei->cache_info.is_extrainfo = 1;
  1771. strlcpy(ei->nickname, get_options()->Nickname, sizeof(ei->nickname));
  1772. ei->cache_info.published_on = ri->cache_info.published_on;
  1773. memcpy(ei->cache_info.identity_digest, ri->cache_info.identity_digest,
  1774. DIGEST_LEN);
  1775. if (extrainfo_dump_to_string(&ei->cache_info.signed_descriptor_body,
  1776. ei, get_server_identity_key()) < 0) {
  1777. log_warn(LD_BUG, "Couldn't generate extra-info descriptor.");
  1778. extrainfo_free(ei);
  1779. ei = NULL;
  1780. } else {
  1781. ei->cache_info.signed_descriptor_len =
  1782. strlen(ei->cache_info.signed_descriptor_body);
  1783. router_get_extrainfo_hash(ei->cache_info.signed_descriptor_body,
  1784. ei->cache_info.signed_descriptor_len,
  1785. ei->cache_info.signed_descriptor_digest);
  1786. }
  1787. /* Now finish the router descriptor. */
  1788. if (ei) {
  1789. memcpy(ri->cache_info.extra_info_digest,
  1790. ei->cache_info.signed_descriptor_digest,
  1791. DIGEST_LEN);
  1792. } else {
  1793. /* ri was allocated with tor_malloc_zero, so there is no need to
  1794. * zero ri->cache_info.extra_info_digest here. */
  1795. }
  1796. if (! (ri->cache_info.signed_descriptor_body = router_dump_router_to_string(
  1797. ri, get_server_identity_key()))) {
  1798. log_warn(LD_BUG, "Couldn't generate router descriptor.");
  1799. routerinfo_free(ri);
  1800. extrainfo_free(ei);
  1801. return -1;
  1802. }
  1803. ri->cache_info.signed_descriptor_len =
  1804. strlen(ri->cache_info.signed_descriptor_body);
  1805. ri->purpose =
  1806. options->BridgeRelay ? ROUTER_PURPOSE_BRIDGE : ROUTER_PURPOSE_GENERAL;
  1807. if (options->BridgeRelay) {
  1808. /* Bridges shouldn't be able to send their descriptors unencrypted,
  1809. anyway, since they don't have a DirPort, and always connect to the
  1810. bridge authority anonymously. But just in case they somehow think of
  1811. sending them on an unencrypted connection, don't allow them to try. */
  1812. ri->cache_info.send_unencrypted = 0;
  1813. if (ei)
  1814. ei->cache_info.send_unencrypted = 0;
  1815. } else {
  1816. ri->cache_info.send_unencrypted = 1;
  1817. if (ei)
  1818. ei->cache_info.send_unencrypted = 1;
  1819. }
  1820. router_get_router_hash(ri->cache_info.signed_descriptor_body,
  1821. strlen(ri->cache_info.signed_descriptor_body),
  1822. ri->cache_info.signed_descriptor_digest);
  1823. if (ei) {
  1824. tor_assert(! routerinfo_incompatible_with_extrainfo(ri, ei, NULL, NULL));
  1825. }
  1826. routerinfo_free(desc_routerinfo);
  1827. desc_routerinfo = ri;
  1828. extrainfo_free(desc_extrainfo);
  1829. desc_extrainfo = ei;
  1830. desc_clean_since = time(NULL);
  1831. desc_needs_upload = 1;
  1832. desc_gen_reason = desc_dirty_reason;
  1833. desc_dirty_reason = NULL;
  1834. control_event_my_descriptor_changed();
  1835. return 0;
  1836. }
  1837. /** If our router descriptor ever goes this long without being regenerated
  1838. * because something changed, we force an immediate regenerate-and-upload. */
  1839. #define FORCE_REGENERATE_DESCRIPTOR_INTERVAL (18*60*60)
  1840. /** If our router descriptor seems to be missing or unacceptable according
  1841. * to the authorities, regenerate and reupload it _this_ often. */
  1842. #define FAST_RETRY_DESCRIPTOR_INTERVAL (90*60)
  1843. /** Mark descriptor out of date if it's been "too long" since we last tried
  1844. * to upload one. */
  1845. void
  1846. mark_my_descriptor_dirty_if_too_old(time_t now)
  1847. {
  1848. networkstatus_t *ns;
  1849. const routerstatus_t *rs;
  1850. const char *retry_fast_reason = NULL; /* Set if we should retry frequently */
  1851. const time_t slow_cutoff = now - FORCE_REGENERATE_DESCRIPTOR_INTERVAL;
  1852. const time_t fast_cutoff = now - FAST_RETRY_DESCRIPTOR_INTERVAL;
  1853. /* If it's already dirty, don't mark it. */
  1854. if (! desc_clean_since)
  1855. return;
  1856. /* If it's older than FORCE_REGENERATE_DESCRIPTOR_INTERVAL, it's always
  1857. * time to rebuild it. */
  1858. if (desc_clean_since < slow_cutoff) {
  1859. mark_my_descriptor_dirty("time for new descriptor");
  1860. return;
  1861. }
  1862. /* Now we see whether we want to be retrying frequently or no. The
  1863. * rule here is that we'll retry frequently if we aren't listed in the
  1864. * live consensus we have, or if the publication time of the
  1865. * descriptor listed for us in the consensus is very old. */
  1866. ns = networkstatus_get_live_consensus(now);
  1867. if (ns) {
  1868. rs = networkstatus_vote_find_entry(ns, server_identitykey_digest);
  1869. if (rs == NULL)
  1870. retry_fast_reason = "not listed in consensus";
  1871. else if (rs->published_on < slow_cutoff)
  1872. retry_fast_reason = "version listed in consensus is quite old";
  1873. }
  1874. if (retry_fast_reason && desc_clean_since < fast_cutoff)
  1875. mark_my_descriptor_dirty(retry_fast_reason);
  1876. }
  1877. /** Call when the current descriptor is out of date. */
  1878. void
  1879. mark_my_descriptor_dirty(const char *reason)
  1880. {
  1881. const or_options_t *options = get_options();
  1882. if (server_mode(options) && options->PublishServerDescriptor_)
  1883. log_info(LD_OR, "Decided to publish new relay descriptor: %s", reason);
  1884. desc_clean_since = 0;
  1885. if (!desc_dirty_reason)
  1886. desc_dirty_reason = reason;
  1887. }
  1888. /** How frequently will we republish our descriptor because of large (factor
  1889. * of 2) shifts in estimated bandwidth? Note: We don't use this constant
  1890. * if our previous bandwidth estimate was exactly 0. */
  1891. #define MAX_BANDWIDTH_CHANGE_FREQ (20*60)
  1892. /** Check whether bandwidth has changed a lot since the last time we announced
  1893. * bandwidth. If so, mark our descriptor dirty. */
  1894. void
  1895. check_descriptor_bandwidth_changed(time_t now)
  1896. {
  1897. static time_t last_changed = 0;
  1898. uint64_t prev, cur;
  1899. if (!desc_routerinfo)
  1900. return;
  1901. prev = desc_routerinfo->bandwidthcapacity;
  1902. cur = we_are_hibernating() ? 0 : rep_hist_bandwidth_assess();
  1903. if ((prev != cur && (!prev || !cur)) ||
  1904. cur > prev*2 ||
  1905. cur < prev/2) {
  1906. if (last_changed+MAX_BANDWIDTH_CHANGE_FREQ < now || !prev) {
  1907. log_info(LD_GENERAL,
  1908. "Measured bandwidth has changed; rebuilding descriptor.");
  1909. mark_my_descriptor_dirty("bandwidth has changed");
  1910. last_changed = now;
  1911. }
  1912. }
  1913. }
  1914. /** Note at log level severity that our best guess of address has changed from
  1915. * <b>prev</b> to <b>cur</b>. */
  1916. static void
  1917. log_addr_has_changed(int severity,
  1918. const tor_addr_t *prev,
  1919. const tor_addr_t *cur,
  1920. const char *source)
  1921. {
  1922. char addrbuf_prev[TOR_ADDR_BUF_LEN];
  1923. char addrbuf_cur[TOR_ADDR_BUF_LEN];
  1924. if (tor_addr_to_str(addrbuf_prev, prev, sizeof(addrbuf_prev), 1) == NULL)
  1925. strlcpy(addrbuf_prev, "???", TOR_ADDR_BUF_LEN);
  1926. if (tor_addr_to_str(addrbuf_cur, cur, sizeof(addrbuf_cur), 1) == NULL)
  1927. strlcpy(addrbuf_cur, "???", TOR_ADDR_BUF_LEN);
  1928. if (!tor_addr_is_null(prev))
  1929. log_fn(severity, LD_GENERAL,
  1930. "Our IP Address has changed from %s to %s; "
  1931. "rebuilding descriptor (source: %s).",
  1932. addrbuf_prev, addrbuf_cur, source);
  1933. else
  1934. log_notice(LD_GENERAL,
  1935. "Guessed our IP address as %s (source: %s).",
  1936. addrbuf_cur, source);
  1937. }
  1938. /** Check whether our own address as defined by the Address configuration
  1939. * has changed. This is for routers that get their address from a service
  1940. * like dyndns. If our address has changed, mark our descriptor dirty. */
  1941. void
  1942. check_descriptor_ipaddress_changed(time_t now)
  1943. {
  1944. uint32_t prev, cur;
  1945. const or_options_t *options = get_options();
  1946. const char *method = NULL;
  1947. char *hostname = NULL;
  1948. (void) now;
  1949. if (!desc_routerinfo)
  1950. return;
  1951. /* XXXX ipv6 */
  1952. prev = desc_routerinfo->addr;
  1953. if (resolve_my_address(LOG_INFO, options, &cur, &method, &hostname) < 0) {
  1954. log_info(LD_CONFIG,"options->Address didn't resolve into an IP.");
  1955. return;
  1956. }
  1957. if (prev != cur) {
  1958. char *source;
  1959. tor_addr_t tmp_prev, tmp_cur;
  1960. tor_addr_from_ipv4h(&tmp_prev, prev);
  1961. tor_addr_from_ipv4h(&tmp_cur, cur);
  1962. tor_asprintf(&source, "METHOD=%s%s%s", method,
  1963. hostname ? " HOSTNAME=" : "",
  1964. hostname ? hostname : "");
  1965. log_addr_has_changed(LOG_NOTICE, &tmp_prev, &tmp_cur, source);
  1966. tor_free(source);
  1967. ip_address_changed(0);
  1968. }
  1969. tor_free(hostname);
  1970. }
  1971. /** The most recently guessed value of our IP address, based on directory
  1972. * headers. */
  1973. static tor_addr_t last_guessed_ip = TOR_ADDR_NULL;
  1974. /** A directory server <b>d_conn</b> told us our IP address is
  1975. * <b>suggestion</b>.
  1976. * If this address is different from the one we think we are now, and
  1977. * if our computer doesn't actually know its IP address, then switch. */
  1978. void
  1979. router_new_address_suggestion(const char *suggestion,
  1980. const dir_connection_t *d_conn)
  1981. {
  1982. tor_addr_t addr;
  1983. uint32_t cur = 0; /* Current IPv4 address. */
  1984. const or_options_t *options = get_options();
  1985. /* first, learn what the IP address actually is */
  1986. if (tor_addr_parse(&addr, suggestion) == -1) {
  1987. log_debug(LD_DIR, "Malformed X-Your-Address-Is header %s. Ignoring.",
  1988. escaped(suggestion));
  1989. return;
  1990. }
  1991. log_debug(LD_DIR, "Got X-Your-Address-Is: %s.", suggestion);
  1992. if (!server_mode(options)) {
  1993. tor_addr_copy(&last_guessed_ip, &addr);
  1994. return;
  1995. }
  1996. /* XXXX ipv6 */
  1997. cur = get_last_resolved_addr();
  1998. if (cur ||
  1999. resolve_my_address(LOG_INFO, options, &cur, NULL, NULL) >= 0) {
  2000. /* We're all set -- we already know our address. Great. */
  2001. tor_addr_from_ipv4h(&last_guessed_ip, cur); /* store it in case we
  2002. need it later */
  2003. return;
  2004. }
  2005. if (tor_addr_is_internal(&addr, 0)) {
  2006. /* Don't believe anybody who says our IP is, say, 127.0.0.1. */
  2007. return;
  2008. }
  2009. if (tor_addr_eq(&d_conn->base_.addr, &addr)) {
  2010. /* Don't believe anybody who says our IP is their IP. */
  2011. log_debug(LD_DIR, "A directory server told us our IP address is %s, "
  2012. "but he's just reporting his own IP address. Ignoring.",
  2013. suggestion);
  2014. return;
  2015. }
  2016. /* Okay. We can't resolve our own address, and X-Your-Address-Is is giving
  2017. * us an answer different from what we had the last time we managed to
  2018. * resolve it. */
  2019. if (!tor_addr_eq(&last_guessed_ip, &addr)) {
  2020. control_event_server_status(LOG_NOTICE,
  2021. "EXTERNAL_ADDRESS ADDRESS=%s METHOD=DIRSERV",
  2022. suggestion);
  2023. log_addr_has_changed(LOG_NOTICE, &last_guessed_ip, &addr,
  2024. d_conn->base_.address);
  2025. ip_address_changed(0);
  2026. tor_addr_copy(&last_guessed_ip, &addr); /* router_rebuild_descriptor()
  2027. will fetch it */
  2028. }
  2029. }
  2030. /** We failed to resolve our address locally, but we'd like to build
  2031. * a descriptor and publish / test reachability. If we have a guess
  2032. * about our address based on directory headers, answer it and return
  2033. * 0; else return -1. */
  2034. static int
  2035. router_guess_address_from_dir_headers(uint32_t *guess)
  2036. {
  2037. if (!tor_addr_is_null(&last_guessed_ip)) {
  2038. *guess = tor_addr_to_ipv4h(&last_guessed_ip);
  2039. return 0;
  2040. }
  2041. return -1;
  2042. }
  2043. /** Set <b>platform</b> (max length <b>len</b>) to a NUL-terminated short
  2044. * string describing the version of Tor and the operating system we're
  2045. * currently running on.
  2046. */
  2047. STATIC void
  2048. get_platform_str(char *platform, size_t len)
  2049. {
  2050. tor_snprintf(platform, len, "Tor %s on %s",
  2051. get_short_version(), get_uname());
  2052. }
  2053. /* XXX need to audit this thing and count fenceposts. maybe
  2054. * refactor so we don't have to keep asking if we're
  2055. * near the end of maxlen?
  2056. */
  2057. #define DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
  2058. /** OR only: Given a routerinfo for this router, and an identity key to sign
  2059. * with, encode the routerinfo as a signed server descriptor and return a new
  2060. * string encoding the result, or NULL on failure.
  2061. */
  2062. char *
  2063. router_dump_router_to_string(routerinfo_t *router,
  2064. crypto_pk_t *ident_key)
  2065. {
  2066. char *address = NULL;
  2067. char *onion_pkey = NULL; /* Onion key, PEM-encoded. */
  2068. char *identity_pkey = NULL; /* Identity key, PEM-encoded. */
  2069. char digest[DIGEST_LEN];
  2070. char published[ISO_TIME_LEN+1];
  2071. char fingerprint[FINGERPRINT_LEN+1];
  2072. int has_extra_info_digest;
  2073. char extra_info_digest[HEX_DIGEST_LEN+1];
  2074. size_t onion_pkeylen, identity_pkeylen;
  2075. char *family_line = NULL;
  2076. char *extra_or_address = NULL;
  2077. const or_options_t *options = get_options();
  2078. smartlist_t *chunks = NULL;
  2079. char *output = NULL;
  2080. /* Make sure the identity key matches the one in the routerinfo. */
  2081. if (!crypto_pk_eq_keys(ident_key, router->identity_pkey)) {
  2082. log_warn(LD_BUG,"Tried to sign a router with a private key that didn't "
  2083. "match router's public key!");
  2084. goto err;
  2085. }
  2086. /* record our fingerprint, so we can include it in the descriptor */
  2087. if (crypto_pk_get_fingerprint(router->identity_pkey, fingerprint, 1)<0) {
  2088. log_err(LD_BUG,"Error computing fingerprint");
  2089. goto err;
  2090. }
  2091. /* PEM-encode the onion key */
  2092. if (crypto_pk_write_public_key_to_string(router->onion_pkey,
  2093. &onion_pkey,&onion_pkeylen)<0) {
  2094. log_warn(LD_BUG,"write onion_pkey to string failed!");
  2095. goto err;
  2096. }
  2097. /* PEM-encode the identity key */
  2098. if (crypto_pk_write_public_key_to_string(router->identity_pkey,
  2099. &identity_pkey,&identity_pkeylen)<0) {
  2100. log_warn(LD_BUG,"write identity_pkey to string failed!");
  2101. goto err;
  2102. }
  2103. /* Encode the publication time. */
  2104. format_iso_time(published, router->cache_info.published_on);
  2105. if (router->declared_family && smartlist_len(router->declared_family)) {
  2106. char *family = smartlist_join_strings(router->declared_family,
  2107. " ", 0, NULL);
  2108. tor_asprintf(&family_line, "family %s\n", family);
  2109. tor_free(family);
  2110. } else {
  2111. family_line = tor_strdup("");
  2112. }
  2113. has_extra_info_digest =
  2114. ! tor_digest_is_zero(router->cache_info.extra_info_digest);
  2115. if (has_extra_info_digest) {
  2116. base16_encode(extra_info_digest, sizeof(extra_info_digest),
  2117. router->cache_info.extra_info_digest, DIGEST_LEN);
  2118. }
  2119. if (router->ipv6_orport &&
  2120. tor_addr_family(&router->ipv6_addr) == AF_INET6) {
  2121. char addr[TOR_ADDR_BUF_LEN];
  2122. const char *a;
  2123. a = tor_addr_to_str(addr, &router->ipv6_addr, sizeof(addr), 1);
  2124. if (a) {
  2125. tor_asprintf(&extra_or_address,
  2126. "or-address %s:%d\n", a, router->ipv6_orport);
  2127. log_debug(LD_OR, "My or-address line is <%s>", extra_or_address);
  2128. }
  2129. }
  2130. address = tor_dup_ip(router->addr);
  2131. chunks = smartlist_new();
  2132. /* Generate the easy portion of the router descriptor. */
  2133. smartlist_add_asprintf(chunks,
  2134. "router %s %s %d 0 %d\n"
  2135. "%s"
  2136. "platform %s\n"
  2137. "protocols Link 1 2 Circuit 1\n"
  2138. "published %s\n"
  2139. "fingerprint %s\n"
  2140. "uptime %ld\n"
  2141. "bandwidth %d %d %d\n"
  2142. "%s%s%s%s"
  2143. "onion-key\n%s"
  2144. "signing-key\n%s"
  2145. "%s%s%s%s",
  2146. router->nickname,
  2147. address,
  2148. router->or_port,
  2149. decide_to_advertise_dirport(options, router->dir_port),
  2150. extra_or_address ? extra_or_address : "",
  2151. router->platform,
  2152. published,
  2153. fingerprint,
  2154. stats_n_seconds_working,
  2155. (int) router->bandwidthrate,
  2156. (int) router->bandwidthburst,
  2157. (int) router->bandwidthcapacity,
  2158. has_extra_info_digest ? "extra-info-digest " : "",
  2159. has_extra_info_digest ? extra_info_digest : "",
  2160. has_extra_info_digest ? "\n" : "",
  2161. (options->DownloadExtraInfo || options->V3AuthoritativeDir) ?
  2162. "caches-extra-info\n" : "",
  2163. onion_pkey, identity_pkey,
  2164. family_line,
  2165. we_are_hibernating() ? "hibernating 1\n" : "",
  2166. options->HidServDirectoryV2 ? "hidden-service-dir\n" : "",
  2167. options->AllowSingleHopExits ? "allow-single-hop-exits\n" : "");
  2168. if (options->ContactInfo && strlen(options->ContactInfo)) {
  2169. const char *ci = options->ContactInfo;
  2170. if (strchr(ci, '\n') || strchr(ci, '\r'))
  2171. ci = escaped(ci);
  2172. smartlist_add_asprintf(chunks, "contact %s\n", ci);
  2173. }
  2174. #ifdef CURVE25519_ENABLED
  2175. if (router->onion_curve25519_pkey) {
  2176. char kbuf[128];
  2177. base64_encode(kbuf, sizeof(kbuf),
  2178. (const char *)router->onion_curve25519_pkey->public_key,
  2179. CURVE25519_PUBKEY_LEN);
  2180. smartlist_add_asprintf(chunks, "ntor-onion-key %s", kbuf);
  2181. }
  2182. #endif
  2183. /* Write the exit policy to the end of 's'. */
  2184. if (!router->exit_policy || !smartlist_len(router->exit_policy)) {
  2185. smartlist_add(chunks, tor_strdup("reject *:*\n"));
  2186. } else if (router->exit_policy) {
  2187. char *exit_policy = router_dump_exit_policy_to_string(router,1,0);
  2188. if (!exit_policy)
  2189. goto err;
  2190. smartlist_add_asprintf(chunks, "%s\n", exit_policy);
  2191. tor_free(exit_policy);
  2192. }
  2193. if (router->ipv6_exit_policy) {
  2194. char *p6 = write_short_policy(router->ipv6_exit_policy);
  2195. if (p6 && strcmp(p6, "reject 1-65535")) {
  2196. smartlist_add_asprintf(chunks,
  2197. "ipv6-policy %s\n", p6);
  2198. }
  2199. tor_free(p6);
  2200. }
  2201. /* Sign the descriptor */
  2202. smartlist_add(chunks, tor_strdup("router-signature\n"));
  2203. crypto_digest_smartlist(digest, DIGEST_LEN, chunks, "", DIGEST_SHA1);
  2204. note_crypto_pk_op(SIGN_RTR);
  2205. {
  2206. char *sig;
  2207. if (!(sig = router_get_dirobj_signature(digest, DIGEST_LEN, ident_key))) {
  2208. log_warn(LD_BUG, "Couldn't sign router descriptor");
  2209. goto err;
  2210. }
  2211. smartlist_add(chunks, sig);
  2212. }
  2213. /* include a last '\n' */
  2214. smartlist_add(chunks, tor_strdup("\n"));
  2215. output = smartlist_join_strings(chunks, "", 0, NULL);
  2216. #ifdef DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
  2217. {
  2218. char *s_dup;
  2219. const char *cp;
  2220. routerinfo_t *ri_tmp;
  2221. cp = s_dup = tor_strdup(output);
  2222. ri_tmp = router_parse_entry_from_string(cp, NULL, 1, 0, NULL);
  2223. if (!ri_tmp) {
  2224. log_err(LD_BUG,
  2225. "We just generated a router descriptor we can't parse.");
  2226. log_err(LD_BUG, "Descriptor was: <<%s>>", output);
  2227. goto err;
  2228. }
  2229. tor_free(s_dup);
  2230. routerinfo_free(ri_tmp);
  2231. }
  2232. #endif
  2233. goto done;
  2234. err:
  2235. tor_free(output); /* sets output to NULL */
  2236. done:
  2237. if (chunks) {
  2238. SMARTLIST_FOREACH(chunks, char *, cp, tor_free(cp));
  2239. smartlist_free(chunks);
  2240. }
  2241. tor_free(address);
  2242. tor_free(family_line);
  2243. tor_free(onion_pkey);
  2244. tor_free(identity_pkey);
  2245. tor_free(extra_or_address);
  2246. return output;
  2247. }
  2248. /**
  2249. * OR only: Given <b>router</b>, produce a string with its exit policy.
  2250. * If <b>include_ipv4</b> is true, include IPv4 entries.
  2251. * If <b>include_ipv6</b> is true, include IPv6 entries.
  2252. */
  2253. char *
  2254. router_dump_exit_policy_to_string(const routerinfo_t *router,
  2255. int include_ipv4,
  2256. int include_ipv6)
  2257. {
  2258. smartlist_t *exit_policy_strings;
  2259. char *policy_string = NULL;
  2260. if ((!router->exit_policy) || (router->policy_is_reject_star)) {
  2261. return tor_strdup("reject *:*");
  2262. }
  2263. exit_policy_strings = smartlist_new();
  2264. SMARTLIST_FOREACH_BEGIN(router->exit_policy, addr_policy_t *, tmpe) {
  2265. char *pbuf;
  2266. int bytes_written_to_pbuf;
  2267. if ((tor_addr_family(&tmpe->addr) == AF_INET6) && (!include_ipv6)) {
  2268. continue; /* Don't include IPv6 parts of address policy */
  2269. }
  2270. if ((tor_addr_family(&tmpe->addr) == AF_INET) && (!include_ipv4)) {
  2271. continue; /* Don't include IPv4 parts of address policy */
  2272. }
  2273. pbuf = tor_malloc(POLICY_BUF_LEN);
  2274. bytes_written_to_pbuf = policy_write_item(pbuf,POLICY_BUF_LEN, tmpe, 1);
  2275. if (bytes_written_to_pbuf < 0) {
  2276. log_warn(LD_BUG, "router_dump_exit_policy_to_string ran out of room!");
  2277. tor_free(pbuf);
  2278. goto done;
  2279. }
  2280. smartlist_add(exit_policy_strings,pbuf);
  2281. } SMARTLIST_FOREACH_END(tmpe);
  2282. policy_string = smartlist_join_strings(exit_policy_strings, "\n", 0, NULL);
  2283. done:
  2284. SMARTLIST_FOREACH(exit_policy_strings, char *, str, tor_free(str));
  2285. smartlist_free(exit_policy_strings);
  2286. return policy_string;
  2287. }
  2288. /** Copy the primary (IPv4) OR port (IP address and TCP port) for
  2289. * <b>router</b> into *<b>ap_out</b>. */
  2290. void
  2291. router_get_prim_orport(const routerinfo_t *router, tor_addr_port_t *ap_out)
  2292. {
  2293. tor_assert(ap_out != NULL);
  2294. tor_addr_from_ipv4h(&ap_out->addr, router->addr);
  2295. ap_out->port = router->or_port;
  2296. }
  2297. /** Return 1 if any of <b>router</b>'s addresses are <b>addr</b>.
  2298. * Otherwise return 0. */
  2299. int
  2300. router_has_addr(const routerinfo_t *router, const tor_addr_t *addr)
  2301. {
  2302. return
  2303. tor_addr_eq_ipv4h(addr, router->addr) ||
  2304. tor_addr_eq(&router->ipv6_addr, addr);
  2305. }
  2306. int
  2307. router_has_orport(const routerinfo_t *router, const tor_addr_port_t *orport)
  2308. {
  2309. return
  2310. (tor_addr_eq_ipv4h(&orport->addr, router->addr) &&
  2311. orport->port == router->or_port) ||
  2312. (tor_addr_eq(&orport->addr, &router->ipv6_addr) &&
  2313. orport->port == router->ipv6_orport);
  2314. }
  2315. /** Load the contents of <b>filename</b>, find the last line starting with
  2316. * <b>end_line</b>, ensure that its timestamp is not more than 25 hours in
  2317. * the past or more than 1 hour in the future with respect to <b>now</b>,
  2318. * and write the file contents starting with that line to *<b>out</b>.
  2319. * Return 1 for success, 0 if the file does not exist, or -1 if the file
  2320. * does not contain a line matching these criteria or other failure. */
  2321. static int
  2322. load_stats_file(const char *filename, const char *end_line, time_t now,
  2323. char **out)
  2324. {
  2325. int r = -1;
  2326. char *fname = get_datadir_fname(filename);
  2327. char *contents, *start = NULL, *tmp, timestr[ISO_TIME_LEN+1];
  2328. time_t written;
  2329. switch (file_status(fname)) {
  2330. case FN_FILE:
  2331. /* X022 Find an alternative to reading the whole file to memory. */
  2332. if ((contents = read_file_to_str(fname, 0, NULL))) {
  2333. tmp = strstr(contents, end_line);
  2334. /* Find last block starting with end_line */
  2335. while (tmp) {
  2336. start = tmp;
  2337. tmp = strstr(tmp + 1, end_line);
  2338. }
  2339. if (!start)
  2340. goto notfound;
  2341. if (strlen(start) < strlen(end_line) + 1 + sizeof(timestr))
  2342. goto notfound;
  2343. strlcpy(timestr, start + 1 + strlen(end_line), sizeof(timestr));
  2344. if (parse_iso_time(timestr, &written) < 0)
  2345. goto notfound;
  2346. if (written < now - (25*60*60) || written > now + (1*60*60))
  2347. goto notfound;
  2348. *out = tor_strdup(start);
  2349. r = 1;
  2350. }
  2351. notfound:
  2352. tor_free(contents);
  2353. break;
  2354. case FN_NOENT:
  2355. r = 0;
  2356. break;
  2357. case FN_ERROR:
  2358. case FN_DIR:
  2359. default:
  2360. break;
  2361. }
  2362. tor_free(fname);
  2363. return r;
  2364. }
  2365. /** Write the contents of <b>extrainfo</b> and aggregated statistics to
  2366. * *<b>s_out</b>, signing them with <b>ident_key</b>. Return 0 on
  2367. * success, negative on failure. */
  2368. int
  2369. extrainfo_dump_to_string(char **s_out, extrainfo_t *extrainfo,
  2370. crypto_pk_t *ident_key)
  2371. {
  2372. const or_options_t *options = get_options();
  2373. char identity[HEX_DIGEST_LEN+1];
  2374. char published[ISO_TIME_LEN+1];
  2375. char digest[DIGEST_LEN];
  2376. char *bandwidth_usage;
  2377. int result;
  2378. static int write_stats_to_extrainfo = 1;
  2379. char sig[DIROBJ_MAX_SIG_LEN+1];
  2380. char *s, *pre, *contents, *cp, *s_dup = NULL;
  2381. time_t now = time(NULL);
  2382. smartlist_t *chunks = smartlist_new();
  2383. extrainfo_t *ei_tmp = NULL;
  2384. base16_encode(identity, sizeof(identity),
  2385. extrainfo->cache_info.identity_digest, DIGEST_LEN);
  2386. format_iso_time(published, extrainfo->cache_info.published_on);
  2387. bandwidth_usage = rep_hist_get_bandwidth_lines();
  2388. tor_asprintf(&pre, "extra-info %s %s\npublished %s\n%s",
  2389. extrainfo->nickname, identity,
  2390. published, bandwidth_usage);
  2391. tor_free(bandwidth_usage);
  2392. smartlist_add(chunks, pre);
  2393. if (geoip_is_loaded(AF_INET))
  2394. smartlist_add_asprintf(chunks, "geoip-db-digest %s\n",
  2395. geoip_db_digest(AF_INET));
  2396. if (geoip_is_loaded(AF_INET6))
  2397. smartlist_add_asprintf(chunks, "geoip6-db-digest %s\n",
  2398. geoip_db_digest(AF_INET6));
  2399. if (options->ExtraInfoStatistics && write_stats_to_extrainfo) {
  2400. log_info(LD_GENERAL, "Adding stats to extra-info descriptor.");
  2401. if (options->DirReqStatistics &&
  2402. load_stats_file("stats"PATH_SEPARATOR"dirreq-stats",
  2403. "dirreq-stats-end", now, &contents) > 0) {
  2404. smartlist_add(chunks, contents);
  2405. }
  2406. if (options->EntryStatistics &&
  2407. load_stats_file("stats"PATH_SEPARATOR"entry-stats",
  2408. "entry-stats-end", now, &contents) > 0) {
  2409. smartlist_add(chunks, contents);
  2410. }
  2411. if (options->CellStatistics &&
  2412. load_stats_file("stats"PATH_SEPARATOR"buffer-stats",
  2413. "cell-stats-end", now, &contents) > 0) {
  2414. smartlist_add(chunks, contents);
  2415. }
  2416. if (options->ExitPortStatistics &&
  2417. load_stats_file("stats"PATH_SEPARATOR"exit-stats",
  2418. "exit-stats-end", now, &contents) > 0) {
  2419. smartlist_add(chunks, contents);
  2420. }
  2421. if (options->ConnDirectionStatistics &&
  2422. load_stats_file("stats"PATH_SEPARATOR"conn-stats",
  2423. "conn-bi-direct", now, &contents) > 0) {
  2424. smartlist_add(chunks, contents);
  2425. }
  2426. }
  2427. /* Add information about the pluggable transports we support. */
  2428. if (options->ServerTransportPlugin) {
  2429. char *pluggable_transports = pt_get_extra_info_descriptor_string();
  2430. if (pluggable_transports)
  2431. smartlist_add(chunks, pluggable_transports);
  2432. }
  2433. if (should_record_bridge_info(options) && write_stats_to_extrainfo) {
  2434. const char *bridge_stats = geoip_get_bridge_stats_extrainfo(now);
  2435. if (bridge_stats) {
  2436. smartlist_add(chunks, tor_strdup(bridge_stats));
  2437. }
  2438. }
  2439. smartlist_add(chunks, tor_strdup("router-signature\n"));
  2440. s = smartlist_join_strings(chunks, "", 0, NULL);
  2441. while (strlen(s) > MAX_EXTRAINFO_UPLOAD_SIZE - DIROBJ_MAX_SIG_LEN) {
  2442. /* So long as there are at least two chunks (one for the initial
  2443. * extra-info line and one for the router-signature), we can keep removing
  2444. * things. */
  2445. if (smartlist_len(chunks) > 2) {
  2446. /* We remove the next-to-last element (remember, len-1 is the last
  2447. element), since we need to keep the router-signature element. */
  2448. int idx = smartlist_len(chunks) - 2;
  2449. char *e = smartlist_get(chunks, idx);
  2450. smartlist_del_keeporder(chunks, idx);
  2451. log_warn(LD_GENERAL, "We just generated an extra-info descriptor "
  2452. "with statistics that exceeds the 50 KB "
  2453. "upload limit. Removing last added "
  2454. "statistics.");
  2455. tor_free(e);
  2456. tor_free(s);
  2457. s = smartlist_join_strings(chunks, "", 0, NULL);
  2458. } else {
  2459. log_warn(LD_BUG, "We just generated an extra-info descriptors that "
  2460. "exceeds the 50 KB upload limit.");
  2461. goto err;
  2462. }
  2463. }
  2464. memset(sig, 0, sizeof(sig));
  2465. if (router_get_extrainfo_hash(s, strlen(s), digest) < 0 ||
  2466. router_append_dirobj_signature(sig, sizeof(sig), digest, DIGEST_LEN,
  2467. ident_key) < 0) {
  2468. log_warn(LD_BUG, "Could not append signature to extra-info "
  2469. "descriptor.");
  2470. goto err;
  2471. }
  2472. smartlist_add(chunks, tor_strdup(sig));
  2473. tor_free(s);
  2474. s = smartlist_join_strings(chunks, "", 0, NULL);
  2475. cp = s_dup = tor_strdup(s);
  2476. ei_tmp = extrainfo_parse_entry_from_string(cp, NULL, 1, NULL);
  2477. if (!ei_tmp) {
  2478. if (write_stats_to_extrainfo) {
  2479. log_warn(LD_GENERAL, "We just generated an extra-info descriptor "
  2480. "with statistics that we can't parse. Not "
  2481. "adding statistics to this or any future "
  2482. "extra-info descriptors.");
  2483. write_stats_to_extrainfo = 0;
  2484. result = extrainfo_dump_to_string(s_out, extrainfo, ident_key);
  2485. goto done;
  2486. } else {
  2487. log_warn(LD_BUG, "We just generated an extrainfo descriptor we "
  2488. "can't parse.");
  2489. goto err;
  2490. }
  2491. }
  2492. *s_out = s;
  2493. s = NULL; /* prevent free */
  2494. result = 0;
  2495. goto done;
  2496. err:
  2497. result = -1;
  2498. done:
  2499. tor_free(s);
  2500. SMARTLIST_FOREACH(chunks, char *, cp, tor_free(cp));
  2501. smartlist_free(chunks);
  2502. tor_free(s_dup);
  2503. extrainfo_free(ei_tmp);
  2504. return result;
  2505. }
  2506. /** Return true iff <b>s</b> is a valid server nickname. (That is, a string
  2507. * containing between 1 and MAX_NICKNAME_LEN characters from
  2508. * LEGAL_NICKNAME_CHARACTERS.) */
  2509. int
  2510. is_legal_nickname(const char *s)
  2511. {
  2512. size_t len;
  2513. tor_assert(s);
  2514. len = strlen(s);
  2515. return len > 0 && len <= MAX_NICKNAME_LEN &&
  2516. strspn(s,LEGAL_NICKNAME_CHARACTERS) == len;
  2517. }
  2518. /** Return true iff <b>s</b> is a valid server nickname or
  2519. * hex-encoded identity-key digest. */
  2520. int
  2521. is_legal_nickname_or_hexdigest(const char *s)
  2522. {
  2523. if (*s!='$')
  2524. return is_legal_nickname(s);
  2525. else
  2526. return is_legal_hexdigest(s);
  2527. }
  2528. /** Return true iff <b>s</b> is a valid hex-encoded identity-key
  2529. * digest. (That is, an optional $, followed by 40 hex characters,
  2530. * followed by either nothing, or = or ~ followed by a nickname, or
  2531. * a character other than =, ~, or a hex character.)
  2532. */
  2533. int
  2534. is_legal_hexdigest(const char *s)
  2535. {
  2536. size_t len;
  2537. tor_assert(s);
  2538. if (s[0] == '$') s++;
  2539. len = strlen(s);
  2540. if (len > HEX_DIGEST_LEN) {
  2541. if (s[HEX_DIGEST_LEN] == '=' ||
  2542. s[HEX_DIGEST_LEN] == '~') {
  2543. if (!is_legal_nickname(s+HEX_DIGEST_LEN+1))
  2544. return 0;
  2545. } else {
  2546. return 0;
  2547. }
  2548. }
  2549. return (len >= HEX_DIGEST_LEN &&
  2550. strspn(s,HEX_CHARACTERS)==HEX_DIGEST_LEN);
  2551. }
  2552. /** Use <b>buf</b> (which must be at least NODE_DESC_BUF_LEN bytes long) to
  2553. * hold a human-readable description of a node with identity digest
  2554. * <b>id_digest</b>, named-status <b>is_named</b>, nickname <b>nickname</b>,
  2555. * and address <b>addr</b> or <b>addr32h</b>.
  2556. *
  2557. * The <b>nickname</b> and <b>addr</b> fields are optional and may be set to
  2558. * NULL. The <b>addr32h</b> field is optional and may be set to 0.
  2559. *
  2560. * Return a pointer to the front of <b>buf</b>.
  2561. */
  2562. const char *
  2563. format_node_description(char *buf,
  2564. const char *id_digest,
  2565. int is_named,
  2566. const char *nickname,
  2567. const tor_addr_t *addr,
  2568. uint32_t addr32h)
  2569. {
  2570. char *cp;
  2571. if (!buf)
  2572. return "<NULL BUFFER>";
  2573. buf[0] = '$';
  2574. base16_encode(buf+1, HEX_DIGEST_LEN+1, id_digest, DIGEST_LEN);
  2575. cp = buf+1+HEX_DIGEST_LEN;
  2576. if (nickname) {
  2577. buf[1+HEX_DIGEST_LEN] = is_named ? '=' : '~';
  2578. strlcpy(buf+1+HEX_DIGEST_LEN+1, nickname, MAX_NICKNAME_LEN+1);
  2579. cp += strlen(cp);
  2580. }
  2581. if (addr32h || addr) {
  2582. memcpy(cp, " at ", 4);
  2583. cp += 4;
  2584. if (addr) {
  2585. tor_addr_to_str(cp, addr, TOR_ADDR_BUF_LEN, 0);
  2586. } else {
  2587. struct in_addr in;
  2588. in.s_addr = htonl(addr32h);
  2589. tor_inet_ntoa(&in, cp, INET_NTOA_BUF_LEN);
  2590. }
  2591. }
  2592. return buf;
  2593. }
  2594. /** Use <b>buf</b> (which must be at least NODE_DESC_BUF_LEN bytes long) to
  2595. * hold a human-readable description of <b>ri</b>.
  2596. *
  2597. *
  2598. * Return a pointer to the front of <b>buf</b>.
  2599. */
  2600. const char *
  2601. router_get_description(char *buf, const routerinfo_t *ri)
  2602. {
  2603. if (!ri)
  2604. return "<null>";
  2605. return format_node_description(buf,
  2606. ri->cache_info.identity_digest,
  2607. router_is_named(ri),
  2608. ri->nickname,
  2609. NULL,
  2610. ri->addr);
  2611. }
  2612. /** Use <b>buf</b> (which must be at least NODE_DESC_BUF_LEN bytes long) to
  2613. * hold a human-readable description of <b>node</b>.
  2614. *
  2615. * Return a pointer to the front of <b>buf</b>.
  2616. */
  2617. const char *
  2618. node_get_description(char *buf, const node_t *node)
  2619. {
  2620. const char *nickname = NULL;
  2621. uint32_t addr32h = 0;
  2622. int is_named = 0;
  2623. if (!node)
  2624. return "<null>";
  2625. if (node->rs) {
  2626. nickname = node->rs->nickname;
  2627. is_named = node->rs->is_named;
  2628. addr32h = node->rs->addr;
  2629. } else if (node->ri) {
  2630. nickname = node->ri->nickname;
  2631. addr32h = node->ri->addr;
  2632. }
  2633. return format_node_description(buf,
  2634. node->identity,
  2635. is_named,
  2636. nickname,
  2637. NULL,
  2638. addr32h);
  2639. }
  2640. /** Use <b>buf</b> (which must be at least NODE_DESC_BUF_LEN bytes long) to
  2641. * hold a human-readable description of <b>rs</b>.
  2642. *
  2643. * Return a pointer to the front of <b>buf</b>.
  2644. */
  2645. const char *
  2646. routerstatus_get_description(char *buf, const routerstatus_t *rs)
  2647. {
  2648. if (!rs)
  2649. return "<null>";
  2650. return format_node_description(buf,
  2651. rs->identity_digest,
  2652. rs->is_named,
  2653. rs->nickname,
  2654. NULL,
  2655. rs->addr);
  2656. }
  2657. /** Use <b>buf</b> (which must be at least NODE_DESC_BUF_LEN bytes long) to
  2658. * hold a human-readable description of <b>ei</b>.
  2659. *
  2660. * Return a pointer to the front of <b>buf</b>.
  2661. */
  2662. const char *
  2663. extend_info_get_description(char *buf, const extend_info_t *ei)
  2664. {
  2665. if (!ei)
  2666. return "<null>";
  2667. return format_node_description(buf,
  2668. ei->identity_digest,
  2669. 0,
  2670. ei->nickname,
  2671. &ei->addr,
  2672. 0);
  2673. }
  2674. /** Return a human-readable description of the routerinfo_t <b>ri</b>.
  2675. *
  2676. * This function is not thread-safe. Each call to this function invalidates
  2677. * previous values returned by this function.
  2678. */
  2679. const char *
  2680. router_describe(const routerinfo_t *ri)
  2681. {
  2682. static char buf[NODE_DESC_BUF_LEN];
  2683. return router_get_description(buf, ri);
  2684. }
  2685. /** Return a human-readable description of the node_t <b>node</b>.
  2686. *
  2687. * This function is not thread-safe. Each call to this function invalidates
  2688. * previous values returned by this function.
  2689. */
  2690. const char *
  2691. node_describe(const node_t *node)
  2692. {
  2693. static char buf[NODE_DESC_BUF_LEN];
  2694. return node_get_description(buf, node);
  2695. }
  2696. /** Return a human-readable description of the routerstatus_t <b>rs</b>.
  2697. *
  2698. * This function is not thread-safe. Each call to this function invalidates
  2699. * previous values returned by this function.
  2700. */
  2701. const char *
  2702. routerstatus_describe(const routerstatus_t *rs)
  2703. {
  2704. static char buf[NODE_DESC_BUF_LEN];
  2705. return routerstatus_get_description(buf, rs);
  2706. }
  2707. /** Return a human-readable description of the extend_info_t <b>ri</b>.
  2708. *
  2709. * This function is not thread-safe. Each call to this function invalidates
  2710. * previous values returned by this function.
  2711. */
  2712. const char *
  2713. extend_info_describe(const extend_info_t *ei)
  2714. {
  2715. static char buf[NODE_DESC_BUF_LEN];
  2716. return extend_info_get_description(buf, ei);
  2717. }
  2718. /** Set <b>buf</b> (which must have MAX_VERBOSE_NICKNAME_LEN+1 bytes) to the
  2719. * verbose representation of the identity of <b>router</b>. The format is:
  2720. * A dollar sign.
  2721. * The upper-case hexadecimal encoding of the SHA1 hash of router's identity.
  2722. * A "=" if the router is named; a "~" if it is not.
  2723. * The router's nickname.
  2724. **/
  2725. void
  2726. router_get_verbose_nickname(char *buf, const routerinfo_t *router)
  2727. {
  2728. const char *good_digest = networkstatus_get_router_digest_by_nickname(
  2729. router->nickname);
  2730. int is_named = good_digest && tor_memeq(good_digest,
  2731. router->cache_info.identity_digest,
  2732. DIGEST_LEN);
  2733. buf[0] = '$';
  2734. base16_encode(buf+1, HEX_DIGEST_LEN+1, router->cache_info.identity_digest,
  2735. DIGEST_LEN);
  2736. buf[1+HEX_DIGEST_LEN] = is_named ? '=' : '~';
  2737. strlcpy(buf+1+HEX_DIGEST_LEN+1, router->nickname, MAX_NICKNAME_LEN+1);
  2738. }
  2739. /** Forget that we have issued any router-related warnings, so that we'll
  2740. * warn again if we see the same errors. */
  2741. void
  2742. router_reset_warnings(void)
  2743. {
  2744. if (warned_nonexistent_family) {
  2745. SMARTLIST_FOREACH(warned_nonexistent_family, char *, cp, tor_free(cp));
  2746. smartlist_clear(warned_nonexistent_family);
  2747. }
  2748. }
  2749. /** Given a router purpose, convert it to a string. Don't call this on
  2750. * ROUTER_PURPOSE_UNKNOWN: The whole point of that value is that we don't
  2751. * know its string representation. */
  2752. const char *
  2753. router_purpose_to_string(uint8_t p)
  2754. {
  2755. switch (p)
  2756. {
  2757. case ROUTER_PURPOSE_GENERAL: return "general";
  2758. case ROUTER_PURPOSE_BRIDGE: return "bridge";
  2759. case ROUTER_PURPOSE_CONTROLLER: return "controller";
  2760. default:
  2761. tor_assert(0);
  2762. }
  2763. return NULL;
  2764. }
  2765. /** Given a string, convert it to a router purpose. */
  2766. uint8_t
  2767. router_purpose_from_string(const char *s)
  2768. {
  2769. if (!strcmp(s, "general"))
  2770. return ROUTER_PURPOSE_GENERAL;
  2771. else if (!strcmp(s, "bridge"))
  2772. return ROUTER_PURPOSE_BRIDGE;
  2773. else if (!strcmp(s, "controller"))
  2774. return ROUTER_PURPOSE_CONTROLLER;
  2775. else
  2776. return ROUTER_PURPOSE_UNKNOWN;
  2777. }
  2778. /** Release all static resources held in router.c */
  2779. void
  2780. router_free_all(void)
  2781. {
  2782. crypto_pk_free(onionkey);
  2783. crypto_pk_free(lastonionkey);
  2784. crypto_pk_free(server_identitykey);
  2785. crypto_pk_free(client_identitykey);
  2786. tor_mutex_free(key_lock);
  2787. routerinfo_free(desc_routerinfo);
  2788. extrainfo_free(desc_extrainfo);
  2789. crypto_pk_free(authority_signing_key);
  2790. authority_cert_free(authority_key_certificate);
  2791. crypto_pk_free(legacy_signing_key);
  2792. authority_cert_free(legacy_key_certificate);
  2793. #ifdef CURVE25519_ENABLED
  2794. memwipe(&curve25519_onion_key, 0, sizeof(curve25519_onion_key));
  2795. memwipe(&last_curve25519_onion_key, 0, sizeof(last_curve25519_onion_key));
  2796. #endif
  2797. if (warned_nonexistent_family) {
  2798. SMARTLIST_FOREACH(warned_nonexistent_family, char *, cp, tor_free(cp));
  2799. smartlist_free(warned_nonexistent_family);
  2800. }
  2801. }
  2802. /** Return a smartlist of tor_addr_port_t's with all the OR ports of
  2803. <b>ri</b>. Note that freeing of the items in the list as well as
  2804. the smartlist itself is the callers responsibility.
  2805. XXX duplicating code from node_get_all_orports(). */
  2806. smartlist_t *
  2807. router_get_all_orports(const routerinfo_t *ri)
  2808. {
  2809. smartlist_t *sl = smartlist_new();
  2810. tor_assert(ri);
  2811. if (ri->addr != 0) {
  2812. tor_addr_port_t *ap = tor_malloc(sizeof(tor_addr_port_t));
  2813. tor_addr_from_ipv4h(&ap->addr, ri->addr);
  2814. ap->port = ri->or_port;
  2815. smartlist_add(sl, ap);
  2816. }
  2817. if (!tor_addr_is_null(&ri->ipv6_addr)) {
  2818. tor_addr_port_t *ap = tor_malloc(sizeof(tor_addr_port_t));
  2819. tor_addr_copy(&ap->addr, &ri->ipv6_addr);
  2820. ap->port = ri->or_port;
  2821. smartlist_add(sl, ap);
  2822. }
  2823. return sl;
  2824. }