router.c 124 KB

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