router.c 121 KB

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