hs_service.c 128 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612
  1. /* Copyright (c) 2016-2018, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file hs_service.c
  5. * \brief Implement next generation hidden service functionality
  6. **/
  7. #define HS_SERVICE_PRIVATE
  8. #include "core/or/or.h"
  9. #include "feature/client/circpathbias.h"
  10. #include "core/or/circuitbuild.h"
  11. #include "core/or/circuitlist.h"
  12. #include "core/or/circuituse.h"
  13. #include "app/config/config.h"
  14. #include "core/mainloop/connection.h"
  15. #include "lib/crypt_ops/crypto_rand.h"
  16. #include "lib/crypt_ops/crypto_util.h"
  17. #include "lib/crypt_ops/crypto_ope.h"
  18. #include "feature/dircache/directory.h"
  19. #include "core/mainloop/main.h"
  20. #include "feature/nodelist/networkstatus.h"
  21. #include "feature/nodelist/nodelist.h"
  22. #include "core/or/relay.h"
  23. #include "feature/rend/rendservice.h"
  24. #include "feature/relay/router.h"
  25. #include "feature/relay/routerkeys.h"
  26. #include "feature/nodelist/routerlist.h"
  27. #include "feature/hs_common/shared_random_client.h"
  28. #include "app/config/statefile.h"
  29. #include "feature/hs/hs_circuit.h"
  30. #include "feature/hs/hs_common.h"
  31. #include "feature/hs/hs_config.h"
  32. #include "feature/hs/hs_control.h"
  33. #include "feature/hs/hs_descriptor.h"
  34. #include "feature/hs/hs_ident.h"
  35. #include "feature/hs/hs_intropoint.h"
  36. #include "feature/hs/hs_service.h"
  37. #include "feature/hs/hs_stats.h"
  38. #include "feature/dircommon/dir_connection_st.h"
  39. #include "core/or/edge_connection_st.h"
  40. #include "core/or/extend_info_st.h"
  41. #include "feature/nodelist/networkstatus_st.h"
  42. #include "feature/nodelist/node_st.h"
  43. #include "core/or/origin_circuit_st.h"
  44. #include "app/config/or_state_st.h"
  45. #include "feature/nodelist/routerstatus_st.h"
  46. #include "lib/encoding/confline.h"
  47. #include "lib/crypt_ops/crypto_format.h"
  48. /* Trunnel */
  49. #include "trunnel/ed25519_cert.h"
  50. #include "trunnel/hs/cell_common.h"
  51. #include "trunnel/hs/cell_establish_intro.h"
  52. #ifdef HAVE_SYS_STAT_H
  53. #include <sys/stat.h>
  54. #endif
  55. #ifdef HAVE_UNISTD_H
  56. #include <unistd.h>
  57. #endif
  58. /* Helper macro. Iterate over every service in the global map. The var is the
  59. * name of the service pointer. */
  60. #define FOR_EACH_SERVICE_BEGIN(var) \
  61. STMT_BEGIN \
  62. hs_service_t **var##_iter, *var; \
  63. HT_FOREACH(var##_iter, hs_service_ht, hs_service_map) { \
  64. var = *var##_iter;
  65. #define FOR_EACH_SERVICE_END } STMT_END ;
  66. /* Helper macro. Iterate over both current and previous descriptor of a
  67. * service. The var is the name of the descriptor pointer. This macro skips
  68. * any descriptor object of the service that is NULL. */
  69. #define FOR_EACH_DESCRIPTOR_BEGIN(service, var) \
  70. STMT_BEGIN \
  71. hs_service_descriptor_t *var; \
  72. for (int var ## _loop_idx = 0; var ## _loop_idx < 2; \
  73. ++var ## _loop_idx) { \
  74. (var ## _loop_idx == 0) ? (var = service->desc_current) : \
  75. (var = service->desc_next); \
  76. if (var == NULL) continue;
  77. #define FOR_EACH_DESCRIPTOR_END } STMT_END ;
  78. /* Onion service directory file names. */
  79. static const char fname_keyfile_prefix[] = "hs_ed25519";
  80. static const char fname_hostname[] = "hostname";
  81. static const char address_tld[] = "onion";
  82. /* Staging list of service object. When configuring service, we add them to
  83. * this list considered a staging area and they will get added to our global
  84. * map once the keys have been loaded. These two steps are separated because
  85. * loading keys requires that we are an actual running tor process. */
  86. static smartlist_t *hs_service_staging_list;
  87. /** True if the list of available router descriptors might have changed which
  88. * might result in an altered hash ring. Check if the hash ring changed and
  89. * reupload if needed */
  90. static int consider_republishing_hs_descriptors = 0;
  91. /* Static declaration. */
  92. static void set_descriptor_revision_counter(hs_service_descriptor_t *hs_desc,
  93. time_t now, bool is_current);
  94. static void move_descriptors(hs_service_t *src, hs_service_t *dst);
  95. /* Helper: Function to compare two objects in the service map. Return 1 if the
  96. * two service have the same master public identity key. */
  97. static inline int
  98. hs_service_ht_eq(const hs_service_t *first, const hs_service_t *second)
  99. {
  100. tor_assert(first);
  101. tor_assert(second);
  102. /* Simple key compare. */
  103. return ed25519_pubkey_eq(&first->keys.identity_pk,
  104. &second->keys.identity_pk);
  105. }
  106. /* Helper: Function for the service hash table code below. The key used is the
  107. * master public identity key which is ultimately the onion address. */
  108. static inline unsigned int
  109. hs_service_ht_hash(const hs_service_t *service)
  110. {
  111. tor_assert(service);
  112. return (unsigned int) siphash24g(service->keys.identity_pk.pubkey,
  113. sizeof(service->keys.identity_pk.pubkey));
  114. }
  115. /* This is _the_ global hash map of hidden services which indexed the service
  116. * contained in it by master public identity key which is roughly the onion
  117. * address of the service. */
  118. static struct hs_service_ht *hs_service_map;
  119. /* Register the service hash table. */
  120. HT_PROTOTYPE(hs_service_ht, /* Name of hashtable. */
  121. hs_service_t, /* Object contained in the map. */
  122. hs_service_node, /* The name of the HT_ENTRY member. */
  123. hs_service_ht_hash, /* Hashing function. */
  124. hs_service_ht_eq) /* Compare function for objects. */
  125. HT_GENERATE2(hs_service_ht, hs_service_t, hs_service_node,
  126. hs_service_ht_hash, hs_service_ht_eq,
  127. 0.6, tor_reallocarray, tor_free_)
  128. /* Query the given service map with a public key and return a service object
  129. * if found else NULL. It is also possible to set a directory path in the
  130. * search query. If pk is NULL, then it will be set to zero indicating the
  131. * hash table to compare the directory path instead. */
  132. STATIC hs_service_t *
  133. find_service(hs_service_ht *map, const ed25519_public_key_t *pk)
  134. {
  135. hs_service_t dummy_service;
  136. tor_assert(map);
  137. tor_assert(pk);
  138. memset(&dummy_service, 0, sizeof(dummy_service));
  139. ed25519_pubkey_copy(&dummy_service.keys.identity_pk, pk);
  140. return HT_FIND(hs_service_ht, map, &dummy_service);
  141. }
  142. /* Register the given service in the given map. If the service already exists
  143. * in the map, -1 is returned. On success, 0 is returned and the service
  144. * ownership has been transferred to the global map. */
  145. STATIC int
  146. register_service(hs_service_ht *map, hs_service_t *service)
  147. {
  148. tor_assert(map);
  149. tor_assert(service);
  150. tor_assert(!ed25519_public_key_is_zero(&service->keys.identity_pk));
  151. if (find_service(map, &service->keys.identity_pk)) {
  152. /* Existing service with the same key. Do not register it. */
  153. return -1;
  154. }
  155. /* Taking ownership of the object at this point. */
  156. HT_INSERT(hs_service_ht, map, service);
  157. /* If we just modified the global map, we notify. */
  158. if (map == hs_service_map) {
  159. hs_service_map_has_changed();
  160. }
  161. return 0;
  162. }
  163. /* Remove a given service from the given map. If service is NULL or the
  164. * service key is unset, return gracefully. */
  165. STATIC void
  166. remove_service(hs_service_ht *map, hs_service_t *service)
  167. {
  168. hs_service_t *elm;
  169. tor_assert(map);
  170. /* Ignore if no service or key is zero. */
  171. if (BUG(service == NULL) ||
  172. BUG(ed25519_public_key_is_zero(&service->keys.identity_pk))) {
  173. return;
  174. }
  175. elm = HT_REMOVE(hs_service_ht, map, service);
  176. if (elm) {
  177. tor_assert(elm == service);
  178. } else {
  179. log_warn(LD_BUG, "Could not find service in the global map "
  180. "while removing service %s",
  181. escaped(service->config.directory_path));
  182. }
  183. /* If we just modified the global map, we notify. */
  184. if (map == hs_service_map) {
  185. hs_service_map_has_changed();
  186. }
  187. }
  188. /* Set the default values for a service configuration object <b>c</b>. */
  189. static void
  190. set_service_default_config(hs_service_config_t *c,
  191. const or_options_t *options)
  192. {
  193. (void) options;
  194. tor_assert(c);
  195. c->ports = smartlist_new();
  196. c->directory_path = NULL;
  197. c->max_streams_per_rdv_circuit = 0;
  198. c->max_streams_close_circuit = 0;
  199. c->num_intro_points = NUM_INTRO_POINTS_DEFAULT;
  200. c->allow_unknown_ports = 0;
  201. c->is_single_onion = 0;
  202. c->dir_group_readable = 0;
  203. c->is_ephemeral = 0;
  204. }
  205. /* From a service configuration object config, clear everything from it
  206. * meaning free allocated pointers and reset the values. */
  207. static void
  208. service_clear_config(hs_service_config_t *config)
  209. {
  210. if (config == NULL) {
  211. return;
  212. }
  213. tor_free(config->directory_path);
  214. if (config->ports) {
  215. SMARTLIST_FOREACH(config->ports, rend_service_port_config_t *, p,
  216. rend_service_port_config_free(p););
  217. smartlist_free(config->ports);
  218. }
  219. memset(config, 0, sizeof(*config));
  220. }
  221. /* Helper function to return a human readable description of the given intro
  222. * point object.
  223. *
  224. * This function is not thread-safe. Each call to this invalidates the
  225. * previous values returned by it. */
  226. static const char *
  227. describe_intro_point(const hs_service_intro_point_t *ip)
  228. {
  229. /* Hex identity digest of the IP prefixed by the $ sign and ends with NUL
  230. * byte hence the plus two. */
  231. static char buf[HEX_DIGEST_LEN + 2];
  232. const char *legacy_id = NULL;
  233. SMARTLIST_FOREACH_BEGIN(ip->base.link_specifiers,
  234. const hs_desc_link_specifier_t *, lspec) {
  235. if (lspec->type == LS_LEGACY_ID) {
  236. legacy_id = (const char *) lspec->u.legacy_id;
  237. break;
  238. }
  239. } SMARTLIST_FOREACH_END(lspec);
  240. /* For now, we only print the identity digest but we could improve this with
  241. * much more information such as the ed25519 identity has well. */
  242. buf[0] = '$';
  243. if (legacy_id) {
  244. base16_encode(buf + 1, HEX_DIGEST_LEN + 1, legacy_id, DIGEST_LEN);
  245. }
  246. return buf;
  247. }
  248. /* Return the lower bound of maximum INTRODUCE2 cells per circuit before we
  249. * rotate intro point (defined by a consensus parameter or the default
  250. * value). */
  251. static int32_t
  252. get_intro_point_min_introduce2(void)
  253. {
  254. /* The [0, 2147483647] range is quite large to accommodate anything we decide
  255. * in the future. */
  256. return networkstatus_get_param(NULL, "hs_intro_min_introduce2",
  257. INTRO_POINT_MIN_LIFETIME_INTRODUCTIONS,
  258. 0, INT32_MAX);
  259. }
  260. /* Return the upper bound of maximum INTRODUCE2 cells per circuit before we
  261. * rotate intro point (defined by a consensus parameter or the default
  262. * value). */
  263. static int32_t
  264. get_intro_point_max_introduce2(void)
  265. {
  266. /* The [0, 2147483647] range is quite large to accommodate anything we decide
  267. * in the future. */
  268. return networkstatus_get_param(NULL, "hs_intro_max_introduce2",
  269. INTRO_POINT_MAX_LIFETIME_INTRODUCTIONS,
  270. 0, INT32_MAX);
  271. }
  272. /* Return the minimum lifetime in seconds of an introduction point defined by a
  273. * consensus parameter or the default value. */
  274. static int32_t
  275. get_intro_point_min_lifetime(void)
  276. {
  277. #define MIN_INTRO_POINT_LIFETIME_TESTING 10
  278. if (get_options()->TestingTorNetwork) {
  279. return MIN_INTRO_POINT_LIFETIME_TESTING;
  280. }
  281. /* The [0, 2147483647] range is quite large to accommodate anything we decide
  282. * in the future. */
  283. return networkstatus_get_param(NULL, "hs_intro_min_lifetime",
  284. INTRO_POINT_LIFETIME_MIN_SECONDS,
  285. 0, INT32_MAX);
  286. }
  287. /* Return the maximum lifetime in seconds of an introduction point defined by a
  288. * consensus parameter or the default value. */
  289. static int32_t
  290. get_intro_point_max_lifetime(void)
  291. {
  292. #define MAX_INTRO_POINT_LIFETIME_TESTING 30
  293. if (get_options()->TestingTorNetwork) {
  294. return MAX_INTRO_POINT_LIFETIME_TESTING;
  295. }
  296. /* The [0, 2147483647] range is quite large to accommodate anything we decide
  297. * in the future. */
  298. return networkstatus_get_param(NULL, "hs_intro_max_lifetime",
  299. INTRO_POINT_LIFETIME_MAX_SECONDS,
  300. 0, INT32_MAX);
  301. }
  302. /* Return the number of extra introduction point defined by a consensus
  303. * parameter or the default value. */
  304. static int32_t
  305. get_intro_point_num_extra(void)
  306. {
  307. /* The [0, 128] range bounds the number of extra introduction point allowed.
  308. * Above 128 intro points, it's getting a bit crazy. */
  309. return networkstatus_get_param(NULL, "hs_intro_num_extra",
  310. NUM_INTRO_POINTS_EXTRA, 0, 128);
  311. }
  312. /* Helper: Function that needs to return 1 for the HT for each loop which
  313. * frees every service in an hash map. */
  314. static int
  315. ht_free_service_(struct hs_service_t *service, void *data)
  316. {
  317. (void) data;
  318. hs_service_free(service);
  319. /* This function MUST return 1 so the given object is then removed from the
  320. * service map leading to this free of the object being safe. */
  321. return 1;
  322. }
  323. /* Free every service that can be found in the global map. Once done, clear
  324. * and free the global map. */
  325. static void
  326. service_free_all(void)
  327. {
  328. if (hs_service_map) {
  329. /* The free helper function returns 1 so this is safe. */
  330. hs_service_ht_HT_FOREACH_FN(hs_service_map, ht_free_service_, NULL);
  331. HT_CLEAR(hs_service_ht, hs_service_map);
  332. tor_free(hs_service_map);
  333. hs_service_map = NULL;
  334. }
  335. if (hs_service_staging_list) {
  336. /* Cleanup staging list. */
  337. SMARTLIST_FOREACH(hs_service_staging_list, hs_service_t *, s,
  338. hs_service_free(s));
  339. smartlist_free(hs_service_staging_list);
  340. hs_service_staging_list = NULL;
  341. }
  342. }
  343. /* Free a given service intro point object. */
  344. STATIC void
  345. service_intro_point_free_(hs_service_intro_point_t *ip)
  346. {
  347. if (!ip) {
  348. return;
  349. }
  350. memwipe(&ip->auth_key_kp, 0, sizeof(ip->auth_key_kp));
  351. memwipe(&ip->enc_key_kp, 0, sizeof(ip->enc_key_kp));
  352. crypto_pk_free(ip->legacy_key);
  353. replaycache_free(ip->replay_cache);
  354. hs_intropoint_clear(&ip->base);
  355. tor_free(ip);
  356. }
  357. /* Helper: free an hs_service_intro_point_t object. This function is used by
  358. * digest256map_free() which requires a void * pointer. */
  359. static void
  360. service_intro_point_free_void(void *obj)
  361. {
  362. service_intro_point_free_(obj);
  363. }
  364. /* Return a newly allocated service intro point and fully initialized from the
  365. * given extend_info_t ei if non NULL.
  366. * If is_legacy is true, we also generate the legacy key.
  367. * If supports_ed25519_link_handshake_any is true, we add the relay's ed25519
  368. * key to the link specifiers.
  369. *
  370. * If ei is NULL, returns a hs_service_intro_point_t with an empty link
  371. * specifier list and no onion key. (This is used for testing.)
  372. * On any other error, NULL is returned.
  373. *
  374. * ei must be an extend_info_t containing an IPv4 address. (We will add supoort
  375. * for IPv6 in a later release.) When calling extend_info_from_node(), pass
  376. * 0 in for_direct_connection to make sure ei always has an IPv4 address. */
  377. STATIC hs_service_intro_point_t *
  378. service_intro_point_new(const extend_info_t *ei, unsigned int is_legacy,
  379. unsigned int supports_ed25519_link_handshake_any)
  380. {
  381. hs_desc_link_specifier_t *ls;
  382. hs_service_intro_point_t *ip;
  383. ip = tor_malloc_zero(sizeof(*ip));
  384. /* We'll create the key material. No need for extra strong, those are short
  385. * term keys. */
  386. ed25519_keypair_generate(&ip->auth_key_kp, 0);
  387. { /* Set introduce2 max cells limit */
  388. int32_t min_introduce2_cells = get_intro_point_min_introduce2();
  389. int32_t max_introduce2_cells = get_intro_point_max_introduce2();
  390. if (BUG(max_introduce2_cells < min_introduce2_cells)) {
  391. goto err;
  392. }
  393. ip->introduce2_max = crypto_rand_int_range(min_introduce2_cells,
  394. max_introduce2_cells);
  395. }
  396. { /* Set intro point lifetime */
  397. int32_t intro_point_min_lifetime = get_intro_point_min_lifetime();
  398. int32_t intro_point_max_lifetime = get_intro_point_max_lifetime();
  399. if (BUG(intro_point_max_lifetime < intro_point_min_lifetime)) {
  400. goto err;
  401. }
  402. ip->time_to_expire = approx_time() +
  403. crypto_rand_int_range(intro_point_min_lifetime,intro_point_max_lifetime);
  404. }
  405. ip->replay_cache = replaycache_new(0, 0);
  406. /* Initialize the base object. We don't need the certificate object. */
  407. ip->base.link_specifiers = smartlist_new();
  408. /* Generate the encryption key for this intro point. */
  409. curve25519_keypair_generate(&ip->enc_key_kp, 0);
  410. /* Figure out if this chosen node supports v3 or is legacy only. */
  411. if (is_legacy) {
  412. ip->base.is_only_legacy = 1;
  413. /* Legacy mode that is doesn't support v3+ with ed25519 auth key. */
  414. ip->legacy_key = crypto_pk_new();
  415. if (crypto_pk_generate_key(ip->legacy_key) < 0) {
  416. goto err;
  417. }
  418. if (crypto_pk_get_digest(ip->legacy_key,
  419. (char *) ip->legacy_key_digest) < 0) {
  420. goto err;
  421. }
  422. }
  423. if (ei == NULL) {
  424. goto done;
  425. }
  426. /* We'll try to add all link specifiers. Legacy is mandatory.
  427. * IPv4 or IPv6 is required, and we always send IPv4. */
  428. ls = hs_desc_link_specifier_new(ei, LS_IPV4);
  429. /* It is impossible to have an extend info object without a v4. */
  430. if (BUG(!ls)) {
  431. goto err;
  432. }
  433. smartlist_add(ip->base.link_specifiers, ls);
  434. ls = hs_desc_link_specifier_new(ei, LS_LEGACY_ID);
  435. /* It is impossible to have an extend info object without an identity
  436. * digest. */
  437. if (BUG(!ls)) {
  438. goto err;
  439. }
  440. smartlist_add(ip->base.link_specifiers, ls);
  441. /* ed25519 identity key is optional for intro points. If the node supports
  442. * ed25519 link authentication, we include it. */
  443. if (supports_ed25519_link_handshake_any) {
  444. ls = hs_desc_link_specifier_new(ei, LS_ED25519_ID);
  445. if (ls) {
  446. smartlist_add(ip->base.link_specifiers, ls);
  447. }
  448. }
  449. /* IPv6 is not supported in this release. */
  450. /* Finally, copy onion key from the extend_info_t object. */
  451. memcpy(&ip->onion_key, &ei->curve25519_onion_key, sizeof(ip->onion_key));
  452. done:
  453. return ip;
  454. err:
  455. service_intro_point_free(ip);
  456. return NULL;
  457. }
  458. /* Add the given intro point object to the given intro point map. The intro
  459. * point MUST have its RSA encryption key set if this is a legacy type or the
  460. * authentication key set otherwise. */
  461. STATIC void
  462. service_intro_point_add(digest256map_t *map, hs_service_intro_point_t *ip)
  463. {
  464. hs_service_intro_point_t *old_ip_entry;
  465. tor_assert(map);
  466. tor_assert(ip);
  467. old_ip_entry = digest256map_set(map, ip->auth_key_kp.pubkey.pubkey, ip);
  468. /* Make sure we didn't just try to double-add an intro point */
  469. tor_assert_nonfatal(!old_ip_entry);
  470. }
  471. /* For a given service, remove the intro point from that service's descriptors
  472. * (check both current and next descriptor) */
  473. STATIC void
  474. service_intro_point_remove(const hs_service_t *service,
  475. const hs_service_intro_point_t *ip)
  476. {
  477. tor_assert(service);
  478. tor_assert(ip);
  479. /* Trying all descriptors. */
  480. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  481. /* We'll try to remove the descriptor on both descriptors which is not
  482. * very expensive to do instead of doing loopup + remove. */
  483. digest256map_remove(desc->intro_points.map,
  484. ip->auth_key_kp.pubkey.pubkey);
  485. } FOR_EACH_DESCRIPTOR_END;
  486. }
  487. /* For a given service and authentication key, return the intro point or NULL
  488. * if not found. This will check both descriptors in the service. */
  489. STATIC hs_service_intro_point_t *
  490. service_intro_point_find(const hs_service_t *service,
  491. const ed25519_public_key_t *auth_key)
  492. {
  493. hs_service_intro_point_t *ip = NULL;
  494. tor_assert(service);
  495. tor_assert(auth_key);
  496. /* Trying all descriptors to find the right intro point.
  497. *
  498. * Even if we use the same node as intro point in both descriptors, the node
  499. * will have a different intro auth key for each descriptor since we generate
  500. * a new one everytime we pick an intro point.
  501. *
  502. * After #22893 gets implemented, intro points will be moved to be
  503. * per-service instead of per-descriptor so this function will need to
  504. * change.
  505. */
  506. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  507. if ((ip = digest256map_get(desc->intro_points.map,
  508. auth_key->pubkey)) != NULL) {
  509. break;
  510. }
  511. } FOR_EACH_DESCRIPTOR_END;
  512. return ip;
  513. }
  514. /* For a given service and intro point, return the descriptor for which the
  515. * intro point is assigned to. NULL is returned if not found. */
  516. STATIC hs_service_descriptor_t *
  517. service_desc_find_by_intro(const hs_service_t *service,
  518. const hs_service_intro_point_t *ip)
  519. {
  520. hs_service_descriptor_t *descp = NULL;
  521. tor_assert(service);
  522. tor_assert(ip);
  523. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  524. if (digest256map_get(desc->intro_points.map,
  525. ip->auth_key_kp.pubkey.pubkey)) {
  526. descp = desc;
  527. break;
  528. }
  529. } FOR_EACH_DESCRIPTOR_END;
  530. return descp;
  531. }
  532. /* From a circuit identifier, get all the possible objects associated with the
  533. * ident. If not NULL, service, ip or desc are set if the object can be found.
  534. * They are untouched if they can't be found.
  535. *
  536. * This is an helper function because we do those lookups often so it's more
  537. * convenient to simply call this functions to get all the things at once. */
  538. STATIC void
  539. get_objects_from_ident(const hs_ident_circuit_t *ident,
  540. hs_service_t **service, hs_service_intro_point_t **ip,
  541. hs_service_descriptor_t **desc)
  542. {
  543. hs_service_t *s;
  544. tor_assert(ident);
  545. /* Get service object from the circuit identifier. */
  546. s = find_service(hs_service_map, &ident->identity_pk);
  547. if (s && service) {
  548. *service = s;
  549. }
  550. /* From the service object, get the intro point object of that circuit. The
  551. * following will query both descriptors intro points list. */
  552. if (s && ip) {
  553. *ip = service_intro_point_find(s, &ident->intro_auth_pk);
  554. }
  555. /* Get the descriptor for this introduction point and service. */
  556. if (s && ip && *ip && desc) {
  557. *desc = service_desc_find_by_intro(s, *ip);
  558. }
  559. }
  560. /* From a given intro point, return the first link specifier of type
  561. * encountered in the link specifier list. Return NULL if it can't be found.
  562. *
  563. * The caller does NOT have ownership of the object, the intro point does. */
  564. static hs_desc_link_specifier_t *
  565. get_link_spec_by_type(const hs_service_intro_point_t *ip, uint8_t type)
  566. {
  567. hs_desc_link_specifier_t *lnk_spec = NULL;
  568. tor_assert(ip);
  569. SMARTLIST_FOREACH_BEGIN(ip->base.link_specifiers,
  570. hs_desc_link_specifier_t *, ls) {
  571. if (ls->type == type) {
  572. lnk_spec = ls;
  573. goto end;
  574. }
  575. } SMARTLIST_FOREACH_END(ls);
  576. end:
  577. return lnk_spec;
  578. }
  579. /* Given a service intro point, return the node_t associated to it. This can
  580. * return NULL if the given intro point has no legacy ID or if the node can't
  581. * be found in the consensus. */
  582. STATIC const node_t *
  583. get_node_from_intro_point(const hs_service_intro_point_t *ip)
  584. {
  585. const hs_desc_link_specifier_t *ls;
  586. tor_assert(ip);
  587. ls = get_link_spec_by_type(ip, LS_LEGACY_ID);
  588. if (BUG(!ls)) {
  589. return NULL;
  590. }
  591. /* XXX In the future, we want to only use the ed25519 ID (#22173). */
  592. return node_get_by_id((const char *) ls->u.legacy_id);
  593. }
  594. /* Given a service intro point, return the extend_info_t for it. This can
  595. * return NULL if the node can't be found for the intro point or the extend
  596. * info can't be created for the found node. If direct_conn is set, the extend
  597. * info is validated on if we can connect directly. */
  598. static extend_info_t *
  599. get_extend_info_from_intro_point(const hs_service_intro_point_t *ip,
  600. unsigned int direct_conn)
  601. {
  602. extend_info_t *info = NULL;
  603. const node_t *node;
  604. tor_assert(ip);
  605. node = get_node_from_intro_point(ip);
  606. if (node == NULL) {
  607. /* This can happen if the relay serving as intro point has been removed
  608. * from the consensus. In that case, the intro point will be removed from
  609. * the descriptor during the scheduled events. */
  610. goto end;
  611. }
  612. /* In the case of a direct connection (single onion service), it is possible
  613. * our firewall policy won't allow it so this can return a NULL value. */
  614. info = extend_info_from_node(node, direct_conn);
  615. end:
  616. return info;
  617. }
  618. /* Return the number of introduction points that are established for the
  619. * given descriptor. */
  620. static unsigned int
  621. count_desc_circuit_established(const hs_service_descriptor_t *desc)
  622. {
  623. unsigned int count = 0;
  624. tor_assert(desc);
  625. DIGEST256MAP_FOREACH(desc->intro_points.map, key,
  626. const hs_service_intro_point_t *, ip) {
  627. count += ip->circuit_established;
  628. } DIGEST256MAP_FOREACH_END;
  629. return count;
  630. }
  631. /* For a given service and descriptor of that service, close all active
  632. * directory connections. */
  633. static void
  634. close_directory_connections(const hs_service_t *service,
  635. const hs_service_descriptor_t *desc)
  636. {
  637. unsigned int count = 0;
  638. smartlist_t *dir_conns;
  639. tor_assert(service);
  640. tor_assert(desc);
  641. /* Close pending HS desc upload connections for the blinded key of 'desc'. */
  642. dir_conns = connection_list_by_type_purpose(CONN_TYPE_DIR,
  643. DIR_PURPOSE_UPLOAD_HSDESC);
  644. SMARTLIST_FOREACH_BEGIN(dir_conns, connection_t *, conn) {
  645. dir_connection_t *dir_conn = TO_DIR_CONN(conn);
  646. if (ed25519_pubkey_eq(&dir_conn->hs_ident->identity_pk,
  647. &service->keys.identity_pk) &&
  648. ed25519_pubkey_eq(&dir_conn->hs_ident->blinded_pk,
  649. &desc->blinded_kp.pubkey)) {
  650. connection_mark_for_close(conn);
  651. count++;
  652. continue;
  653. }
  654. } SMARTLIST_FOREACH_END(conn);
  655. log_info(LD_REND, "Closed %u active service directory connections for "
  656. "descriptor %s of service %s",
  657. count, safe_str_client(ed25519_fmt(&desc->blinded_kp.pubkey)),
  658. safe_str_client(service->onion_address));
  659. /* We don't have ownership of the objects in this list. */
  660. smartlist_free(dir_conns);
  661. }
  662. /* Close all rendezvous circuits for the given service. */
  663. static void
  664. close_service_rp_circuits(hs_service_t *service)
  665. {
  666. origin_circuit_t *ocirc = NULL;
  667. tor_assert(service);
  668. /* The reason we go over all circuit instead of using the circuitmap API is
  669. * because most hidden service circuits are rendezvous circuits so there is
  670. * no real improvement at getting all rendezvous circuits from the
  671. * circuitmap and then going over them all to find the right ones.
  672. * Furthermore, another option would have been to keep a list of RP cookies
  673. * for a service but it creates an engineering complexity since we don't
  674. * have a "RP circuit closed" event to clean it up properly so we avoid a
  675. * memory DoS possibility. */
  676. while ((ocirc = circuit_get_next_service_rp_circ(ocirc))) {
  677. /* Only close circuits that are v3 and for this service. */
  678. if (ocirc->hs_ident != NULL &&
  679. ed25519_pubkey_eq(&ocirc->hs_ident->identity_pk,
  680. &service->keys.identity_pk)) {
  681. /* Reason is FINISHED because service has been removed and thus the
  682. * circuit is considered old/uneeded. When freed, it is removed from the
  683. * hs circuitmap. */
  684. circuit_mark_for_close(TO_CIRCUIT(ocirc), END_CIRC_REASON_FINISHED);
  685. }
  686. }
  687. }
  688. /* Close the circuit(s) for the given map of introduction points. */
  689. static void
  690. close_intro_circuits(hs_service_intropoints_t *intro_points)
  691. {
  692. tor_assert(intro_points);
  693. DIGEST256MAP_FOREACH(intro_points->map, key,
  694. const hs_service_intro_point_t *, ip) {
  695. origin_circuit_t *ocirc = hs_circ_service_get_intro_circ(ip);
  696. if (ocirc) {
  697. /* Reason is FINISHED because service has been removed and thus the
  698. * circuit is considered old/uneeded. When freed, the circuit is removed
  699. * from the HS circuitmap. */
  700. circuit_mark_for_close(TO_CIRCUIT(ocirc), END_CIRC_REASON_FINISHED);
  701. }
  702. } DIGEST256MAP_FOREACH_END;
  703. }
  704. /* Close all introduction circuits for the given service. */
  705. static void
  706. close_service_intro_circuits(hs_service_t *service)
  707. {
  708. tor_assert(service);
  709. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  710. close_intro_circuits(&desc->intro_points);
  711. } FOR_EACH_DESCRIPTOR_END;
  712. }
  713. /* Close any circuits related to the given service. */
  714. static void
  715. close_service_circuits(hs_service_t *service)
  716. {
  717. tor_assert(service);
  718. /* Only support for version >= 3. */
  719. if (BUG(service->config.version < HS_VERSION_THREE)) {
  720. return;
  721. }
  722. /* Close intro points. */
  723. close_service_intro_circuits(service);
  724. /* Close rendezvous points. */
  725. close_service_rp_circuits(service);
  726. }
  727. /* Move every ephemeral services from the src service map to the dst service
  728. * map. It is possible that a service can't be register to the dst map which
  729. * won't stop the process of moving them all but will trigger a log warn. */
  730. static void
  731. move_ephemeral_services(hs_service_ht *src, hs_service_ht *dst)
  732. {
  733. hs_service_t **iter, **next;
  734. tor_assert(src);
  735. tor_assert(dst);
  736. /* Iterate over the map to find ephemeral service and move them to the other
  737. * map. We loop using this method to have a safe removal process. */
  738. for (iter = HT_START(hs_service_ht, src); iter != NULL; iter = next) {
  739. hs_service_t *s = *iter;
  740. if (!s->config.is_ephemeral) {
  741. /* Yeah, we are in a very manual loop :). */
  742. next = HT_NEXT(hs_service_ht, src, iter);
  743. continue;
  744. }
  745. /* Remove service from map and then register to it to the other map.
  746. * Reminder that "*iter" and "s" are the same thing. */
  747. next = HT_NEXT_RMV(hs_service_ht, src, iter);
  748. if (register_service(dst, s) < 0) {
  749. log_warn(LD_BUG, "Ephemeral service key is already being used. "
  750. "Skipping.");
  751. }
  752. }
  753. }
  754. /* Return a const string of the directory path escaped. If this is an
  755. * ephemeral service, it returns "[EPHEMERAL]". This can only be called from
  756. * the main thread because escaped() uses a static variable. */
  757. static const char *
  758. service_escaped_dir(const hs_service_t *s)
  759. {
  760. return (s->config.is_ephemeral) ? "[EPHEMERAL]" :
  761. escaped(s->config.directory_path);
  762. }
  763. /** Move the hidden service state from <b>src</b> to <b>dst</b>. We do this
  764. * when we receive a SIGHUP: <b>dst</b> is the post-HUP service */
  765. static void
  766. move_hs_state(hs_service_t *src_service, hs_service_t *dst_service)
  767. {
  768. tor_assert(src_service);
  769. tor_assert(dst_service);
  770. hs_service_state_t *src = &src_service->state;
  771. hs_service_state_t *dst = &dst_service->state;
  772. /* Let's do a shallow copy */
  773. dst->intro_circ_retry_started_time = src->intro_circ_retry_started_time;
  774. dst->num_intro_circ_launched = src->num_intro_circ_launched;
  775. /* Freeing a NULL replaycache triggers an info LD_BUG. */
  776. if (dst->replay_cache_rend_cookie != NULL) {
  777. replaycache_free(dst->replay_cache_rend_cookie);
  778. }
  779. dst->replay_cache_rend_cookie = src->replay_cache_rend_cookie;
  780. dst->next_rotation_time = src->next_rotation_time;
  781. src->replay_cache_rend_cookie = NULL; /* steal pointer reference */
  782. }
  783. /* Register services that are in the staging list. Once this function returns,
  784. * the global service map will be set with the right content and all non
  785. * surviving services will be cleaned up. */
  786. static void
  787. register_all_services(void)
  788. {
  789. struct hs_service_ht *new_service_map;
  790. tor_assert(hs_service_staging_list);
  791. /* Allocate a new map that will replace the current one. */
  792. new_service_map = tor_malloc_zero(sizeof(*new_service_map));
  793. HT_INIT(hs_service_ht, new_service_map);
  794. /* First step is to transfer all ephemeral services from the current global
  795. * map to the new one we are constructing. We do not prune ephemeral
  796. * services as the only way to kill them is by deleting it from the control
  797. * port or stopping the tor daemon. */
  798. move_ephemeral_services(hs_service_map, new_service_map);
  799. SMARTLIST_FOREACH_BEGIN(hs_service_staging_list, hs_service_t *, snew) {
  800. hs_service_t *s;
  801. /* Check if that service is already in our global map and if so, we'll
  802. * transfer the intro points to it. */
  803. s = find_service(hs_service_map, &snew->keys.identity_pk);
  804. if (s) {
  805. /* Pass ownership of the descriptors from s (the current service) to
  806. * snew (the newly configured one). */
  807. move_descriptors(s, snew);
  808. move_hs_state(s, snew);
  809. /* Remove the service from the global map because after this, we need to
  810. * go over the remaining service in that map that aren't surviving the
  811. * reload to close their circuits. */
  812. remove_service(hs_service_map, s);
  813. hs_service_free(s);
  814. }
  815. /* Great, this service is now ready to be added to our new map. */
  816. if (BUG(register_service(new_service_map, snew) < 0)) {
  817. /* This should never happen because prior to registration, we validate
  818. * every service against the entire set. Not being able to register a
  819. * service means we failed to validate correctly. In that case, don't
  820. * break tor and ignore the service but tell user. */
  821. log_warn(LD_BUG, "Unable to register service with directory %s",
  822. service_escaped_dir(snew));
  823. SMARTLIST_DEL_CURRENT(hs_service_staging_list, snew);
  824. hs_service_free(snew);
  825. }
  826. } SMARTLIST_FOREACH_END(snew);
  827. /* Close any circuits associated with the non surviving services. Every
  828. * service in the current global map are roaming. */
  829. FOR_EACH_SERVICE_BEGIN(service) {
  830. close_service_circuits(service);
  831. } FOR_EACH_SERVICE_END;
  832. /* Time to make the switch. We'll clear the staging list because its content
  833. * has now changed ownership to the map. */
  834. smartlist_clear(hs_service_staging_list);
  835. service_free_all();
  836. hs_service_map = new_service_map;
  837. /* We've just register services into the new map and now we've replaced the
  838. * global map with it so we have to notify that the change happened. When
  839. * registering a service, the notify is only triggered if the destination
  840. * map is the global map for which in here it was not. */
  841. hs_service_map_has_changed();
  842. }
  843. /* Write the onion address of a given service to the given filename fname_ in
  844. * the service directory. Return 0 on success else -1 on error. */
  845. STATIC int
  846. write_address_to_file(const hs_service_t *service, const char *fname_)
  847. {
  848. int ret = -1;
  849. char *fname = NULL;
  850. char *addr_buf = NULL;
  851. tor_assert(service);
  852. tor_assert(fname_);
  853. /* Construct the full address with the onion tld and write the hostname file
  854. * to disk. */
  855. tor_asprintf(&addr_buf, "%s.%s\n", service->onion_address, address_tld);
  856. /* Notice here that we use the given "fname_". */
  857. fname = hs_path_from_filename(service->config.directory_path, fname_);
  858. if (write_str_to_file(fname, addr_buf, 0) < 0) {
  859. log_warn(LD_REND, "Could not write onion address to hostname file %s",
  860. escaped(fname));
  861. goto end;
  862. }
  863. #ifndef _WIN32
  864. if (service->config.dir_group_readable) {
  865. /* Mode to 0640. */
  866. if (chmod(fname, S_IRUSR | S_IWUSR | S_IRGRP) < 0) {
  867. log_warn(LD_FS, "Unable to make onion service hostname file %s "
  868. "group-readable.", escaped(fname));
  869. }
  870. }
  871. #endif /* !defined(_WIN32) */
  872. /* Success. */
  873. ret = 0;
  874. end:
  875. tor_free(fname);
  876. tor_free(addr_buf);
  877. return ret;
  878. }
  879. /* Load and/or generate private keys for the given service. On success, the
  880. * hostname file will be written to disk along with the master private key iff
  881. * the service is not configured for offline keys. Return 0 on success else -1
  882. * on failure. */
  883. static int
  884. load_service_keys(hs_service_t *service)
  885. {
  886. int ret = -1;
  887. char *fname = NULL;
  888. ed25519_keypair_t *kp;
  889. const hs_service_config_t *config;
  890. tor_assert(service);
  891. config = &service->config;
  892. /* Create and fix permission on service directory. We are about to write
  893. * files to that directory so make sure it exists and has the right
  894. * permissions. We do this here because at this stage we know that Tor is
  895. * actually running and the service we have has been validated. */
  896. if (BUG(hs_check_service_private_dir(get_options()->User,
  897. config->directory_path,
  898. config->dir_group_readable, 1) < 0)) {
  899. goto end;
  900. }
  901. /* Try to load the keys from file or generate it if not found. */
  902. fname = hs_path_from_filename(config->directory_path, fname_keyfile_prefix);
  903. /* Don't ask for key creation, we want to know if we were able to load it or
  904. * we had to generate it. Better logging! */
  905. kp = ed_key_init_from_file(fname, INIT_ED_KEY_SPLIT, LOG_INFO, NULL, 0, 0,
  906. 0, NULL, NULL);
  907. if (!kp) {
  908. log_info(LD_REND, "Unable to load keys from %s. Generating it...", fname);
  909. /* We'll now try to generate the keys and for it we want the strongest
  910. * randomness for it. The keypair will be written in different files. */
  911. uint32_t key_flags = INIT_ED_KEY_CREATE | INIT_ED_KEY_EXTRA_STRONG |
  912. INIT_ED_KEY_SPLIT;
  913. kp = ed_key_init_from_file(fname, key_flags, LOG_WARN, NULL, 0, 0, 0,
  914. NULL, NULL);
  915. if (!kp) {
  916. log_warn(LD_REND, "Unable to generate keys and save in %s.", fname);
  917. goto end;
  918. }
  919. }
  920. /* Copy loaded or generated keys to service object. */
  921. ed25519_pubkey_copy(&service->keys.identity_pk, &kp->pubkey);
  922. memcpy(&service->keys.identity_sk, &kp->seckey,
  923. sizeof(service->keys.identity_sk));
  924. /* This does a proper memory wipe. */
  925. ed25519_keypair_free(kp);
  926. /* Build onion address from the newly loaded keys. */
  927. tor_assert(service->config.version <= UINT8_MAX);
  928. hs_build_address(&service->keys.identity_pk,
  929. (uint8_t) service->config.version,
  930. service->onion_address);
  931. /* Write onion address to hostname file. */
  932. if (write_address_to_file(service, fname_hostname) < 0) {
  933. goto end;
  934. }
  935. /* Succes. */
  936. ret = 0;
  937. end:
  938. tor_free(fname);
  939. return ret;
  940. }
  941. /* Free a given service descriptor object and all key material is wiped. */
  942. STATIC void
  943. service_descriptor_free_(hs_service_descriptor_t *desc)
  944. {
  945. if (!desc) {
  946. return;
  947. }
  948. hs_descriptor_free(desc->desc);
  949. memwipe(&desc->signing_kp, 0, sizeof(desc->signing_kp));
  950. memwipe(&desc->blinded_kp, 0, sizeof(desc->blinded_kp));
  951. /* Cleanup all intro points. */
  952. digest256map_free(desc->intro_points.map, service_intro_point_free_void);
  953. digestmap_free(desc->intro_points.failed_id, tor_free_);
  954. if (desc->previous_hsdirs) {
  955. SMARTLIST_FOREACH(desc->previous_hsdirs, char *, s, tor_free(s));
  956. smartlist_free(desc->previous_hsdirs);
  957. }
  958. crypto_ope_free(desc->ope_cipher);
  959. tor_free(desc);
  960. }
  961. /* Return a newly allocated service descriptor object. */
  962. STATIC hs_service_descriptor_t *
  963. service_descriptor_new(void)
  964. {
  965. hs_service_descriptor_t *sdesc = tor_malloc_zero(sizeof(*sdesc));
  966. sdesc->desc = tor_malloc_zero(sizeof(hs_descriptor_t));
  967. /* Initialize the intro points map. */
  968. sdesc->intro_points.map = digest256map_new();
  969. sdesc->intro_points.failed_id = digestmap_new();
  970. sdesc->previous_hsdirs = smartlist_new();
  971. return sdesc;
  972. }
  973. /* Move descriptor(s) from the src service to the dst service. We do this
  974. * during SIGHUP when we re-create our hidden services. */
  975. static void
  976. move_descriptors(hs_service_t *src, hs_service_t *dst)
  977. {
  978. tor_assert(src);
  979. tor_assert(dst);
  980. if (src->desc_current) {
  981. /* Nothing should be there, but clean it up just in case */
  982. if (BUG(dst->desc_current)) {
  983. service_descriptor_free(dst->desc_current);
  984. }
  985. dst->desc_current = src->desc_current;
  986. src->desc_current = NULL;
  987. }
  988. if (src->desc_next) {
  989. /* Nothing should be there, but clean it up just in case */
  990. if (BUG(dst->desc_next)) {
  991. service_descriptor_free(dst->desc_next);
  992. }
  993. dst->desc_next = src->desc_next;
  994. src->desc_next = NULL;
  995. }
  996. }
  997. /* From the given service, remove all expired failing intro points for each
  998. * descriptor. */
  999. static void
  1000. remove_expired_failing_intro(hs_service_t *service, time_t now)
  1001. {
  1002. tor_assert(service);
  1003. /* For both descriptors, cleanup the failing intro points list. */
  1004. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  1005. DIGESTMAP_FOREACH_MODIFY(desc->intro_points.failed_id, key, time_t *, t) {
  1006. time_t failure_time = *t;
  1007. if ((failure_time + INTRO_CIRC_RETRY_PERIOD) <= now) {
  1008. MAP_DEL_CURRENT(key);
  1009. tor_free(t);
  1010. }
  1011. } DIGESTMAP_FOREACH_END;
  1012. } FOR_EACH_DESCRIPTOR_END;
  1013. }
  1014. /* For the given descriptor desc, put all node_t object found from its failing
  1015. * intro point list and put them in the given node_list. */
  1016. static void
  1017. setup_intro_point_exclude_list(const hs_service_descriptor_t *desc,
  1018. smartlist_t *node_list)
  1019. {
  1020. tor_assert(desc);
  1021. tor_assert(node_list);
  1022. DIGESTMAP_FOREACH(desc->intro_points.failed_id, key, time_t *, t) {
  1023. (void) t; /* Make gcc happy. */
  1024. const node_t *node = node_get_by_id(key);
  1025. if (node) {
  1026. smartlist_add(node_list, (void *) node);
  1027. }
  1028. } DIGESTMAP_FOREACH_END;
  1029. }
  1030. /* For the given failing intro point ip, we add its time of failure to the
  1031. * failed map and index it by identity digest (legacy ID) in the descriptor
  1032. * desc failed id map. */
  1033. static void
  1034. remember_failing_intro_point(const hs_service_intro_point_t *ip,
  1035. hs_service_descriptor_t *desc, time_t now)
  1036. {
  1037. time_t *time_of_failure, *prev_ptr;
  1038. const hs_desc_link_specifier_t *legacy_ls;
  1039. tor_assert(ip);
  1040. tor_assert(desc);
  1041. time_of_failure = tor_malloc_zero(sizeof(time_t));
  1042. *time_of_failure = now;
  1043. legacy_ls = get_link_spec_by_type(ip, LS_LEGACY_ID);
  1044. tor_assert(legacy_ls);
  1045. prev_ptr = digestmap_set(desc->intro_points.failed_id,
  1046. (const char *) legacy_ls->u.legacy_id,
  1047. time_of_failure);
  1048. tor_free(prev_ptr);
  1049. }
  1050. /* Copy the descriptor link specifier object from src to dst. */
  1051. static void
  1052. link_specifier_copy(hs_desc_link_specifier_t *dst,
  1053. const hs_desc_link_specifier_t *src)
  1054. {
  1055. tor_assert(dst);
  1056. tor_assert(src);
  1057. memcpy(dst, src, sizeof(hs_desc_link_specifier_t));
  1058. }
  1059. /* Using a given descriptor signing keypair signing_kp, a service intro point
  1060. * object ip and the time now, setup the content of an already allocated
  1061. * descriptor intro desc_ip.
  1062. *
  1063. * Return 0 on success else a negative value. */
  1064. static int
  1065. setup_desc_intro_point(const ed25519_keypair_t *signing_kp,
  1066. const hs_service_intro_point_t *ip,
  1067. time_t now, hs_desc_intro_point_t *desc_ip)
  1068. {
  1069. int ret = -1;
  1070. time_t nearest_hour = now - (now % 3600);
  1071. tor_assert(signing_kp);
  1072. tor_assert(ip);
  1073. tor_assert(desc_ip);
  1074. /* Copy the onion key. */
  1075. memcpy(&desc_ip->onion_key, &ip->onion_key, sizeof(desc_ip->onion_key));
  1076. /* Key and certificate material. */
  1077. desc_ip->auth_key_cert = tor_cert_create(signing_kp,
  1078. CERT_TYPE_AUTH_HS_IP_KEY,
  1079. &ip->auth_key_kp.pubkey,
  1080. nearest_hour,
  1081. HS_DESC_CERT_LIFETIME,
  1082. CERT_FLAG_INCLUDE_SIGNING_KEY);
  1083. if (desc_ip->auth_key_cert == NULL) {
  1084. log_warn(LD_REND, "Unable to create intro point auth-key certificate");
  1085. goto done;
  1086. }
  1087. /* Copy link specifier(s). */
  1088. SMARTLIST_FOREACH_BEGIN(ip->base.link_specifiers,
  1089. const hs_desc_link_specifier_t *, ls) {
  1090. hs_desc_link_specifier_t *copy = tor_malloc_zero(sizeof(*copy));
  1091. link_specifier_copy(copy, ls);
  1092. smartlist_add(desc_ip->link_specifiers, copy);
  1093. } SMARTLIST_FOREACH_END(ls);
  1094. /* For a legacy intro point, we'll use an RSA/ed cross certificate. */
  1095. if (ip->base.is_only_legacy) {
  1096. desc_ip->legacy.key = crypto_pk_dup_key(ip->legacy_key);
  1097. /* Create cross certification cert. */
  1098. ssize_t cert_len = tor_make_rsa_ed25519_crosscert(
  1099. &signing_kp->pubkey,
  1100. desc_ip->legacy.key,
  1101. nearest_hour + HS_DESC_CERT_LIFETIME,
  1102. &desc_ip->legacy.cert.encoded);
  1103. if (cert_len < 0) {
  1104. log_warn(LD_REND, "Unable to create enc key legacy cross cert.");
  1105. goto done;
  1106. }
  1107. desc_ip->legacy.cert.len = cert_len;
  1108. }
  1109. /* Encryption key and its cross certificate. */
  1110. {
  1111. ed25519_public_key_t ed25519_pubkey;
  1112. /* Use the public curve25519 key. */
  1113. memcpy(&desc_ip->enc_key, &ip->enc_key_kp.pubkey,
  1114. sizeof(desc_ip->enc_key));
  1115. /* The following can't fail. */
  1116. ed25519_public_key_from_curve25519_public_key(&ed25519_pubkey,
  1117. &ip->enc_key_kp.pubkey,
  1118. 0);
  1119. desc_ip->enc_key_cert = tor_cert_create(signing_kp,
  1120. CERT_TYPE_CROSS_HS_IP_KEYS,
  1121. &ed25519_pubkey, nearest_hour,
  1122. HS_DESC_CERT_LIFETIME,
  1123. CERT_FLAG_INCLUDE_SIGNING_KEY);
  1124. if (desc_ip->enc_key_cert == NULL) {
  1125. log_warn(LD_REND, "Unable to create enc key curve25519 cross cert.");
  1126. goto done;
  1127. }
  1128. }
  1129. /* Success. */
  1130. ret = 0;
  1131. done:
  1132. return ret;
  1133. }
  1134. /* Using the given descriptor from the given service, build the descriptor
  1135. * intro point list so we can then encode the descriptor for publication. This
  1136. * function does not pick intro points, they have to be in the descriptor
  1137. * current map. Cryptographic material (keys) must be initialized in the
  1138. * descriptor for this function to make sense. */
  1139. static void
  1140. build_desc_intro_points(const hs_service_t *service,
  1141. hs_service_descriptor_t *desc, time_t now)
  1142. {
  1143. hs_desc_encrypted_data_t *encrypted;
  1144. tor_assert(service);
  1145. tor_assert(desc);
  1146. /* Ease our life. */
  1147. encrypted = &desc->desc->encrypted_data;
  1148. /* Cleanup intro points, we are about to set them from scratch. */
  1149. hs_descriptor_clear_intro_points(desc->desc);
  1150. DIGEST256MAP_FOREACH(desc->intro_points.map, key,
  1151. const hs_service_intro_point_t *, ip) {
  1152. hs_desc_intro_point_t *desc_ip = hs_desc_intro_point_new();
  1153. if (setup_desc_intro_point(&desc->signing_kp, ip, now, desc_ip) < 0) {
  1154. hs_desc_intro_point_free(desc_ip);
  1155. continue;
  1156. }
  1157. /* We have a valid descriptor intro point. Add it to the list. */
  1158. smartlist_add(encrypted->intro_points, desc_ip);
  1159. } DIGEST256MAP_FOREACH_END;
  1160. }
  1161. /* Populate the descriptor encrypted section from the given service object.
  1162. * This will generate a valid list of introduction points that can be used
  1163. * after for circuit creation. Return 0 on success else -1 on error. */
  1164. static int
  1165. build_service_desc_encrypted(const hs_service_t *service,
  1166. hs_service_descriptor_t *desc)
  1167. {
  1168. hs_desc_encrypted_data_t *encrypted;
  1169. tor_assert(service);
  1170. tor_assert(desc);
  1171. encrypted = &desc->desc->encrypted_data;
  1172. encrypted->create2_ntor = 1;
  1173. encrypted->single_onion_service = service->config.is_single_onion;
  1174. /* Setup introduction points from what we have in the service. */
  1175. if (encrypted->intro_points == NULL) {
  1176. encrypted->intro_points = smartlist_new();
  1177. }
  1178. /* We do NOT build introduction point yet, we only do that once the circuit
  1179. * have been opened. Until we have the right number of introduction points,
  1180. * we do not encode anything in the descriptor. */
  1181. /* XXX: Support client authorization (#20700). */
  1182. encrypted->intro_auth_types = NULL;
  1183. return 0;
  1184. }
  1185. /* Populate the descriptor plaintext section from the given service object.
  1186. * The caller must make sure that the keys in the descriptors are valid that
  1187. * is are non-zero. Return 0 on success else -1 on error. */
  1188. static int
  1189. build_service_desc_plaintext(const hs_service_t *service,
  1190. hs_service_descriptor_t *desc, time_t now)
  1191. {
  1192. int ret = -1;
  1193. hs_desc_plaintext_data_t *plaintext;
  1194. tor_assert(service);
  1195. tor_assert(desc);
  1196. /* XXX: Use a "assert_desc_ok()" ? */
  1197. tor_assert(!tor_mem_is_zero((char *) &desc->blinded_kp,
  1198. sizeof(desc->blinded_kp)));
  1199. tor_assert(!tor_mem_is_zero((char *) &desc->signing_kp,
  1200. sizeof(desc->signing_kp)));
  1201. /* Set the subcredential. */
  1202. hs_get_subcredential(&service->keys.identity_pk, &desc->blinded_kp.pubkey,
  1203. desc->desc->subcredential);
  1204. plaintext = &desc->desc->plaintext_data;
  1205. plaintext->version = service->config.version;
  1206. plaintext->lifetime_sec = HS_DESC_DEFAULT_LIFETIME;
  1207. plaintext->signing_key_cert =
  1208. tor_cert_create(&desc->blinded_kp, CERT_TYPE_SIGNING_HS_DESC,
  1209. &desc->signing_kp.pubkey, now, HS_DESC_CERT_LIFETIME,
  1210. CERT_FLAG_INCLUDE_SIGNING_KEY);
  1211. if (plaintext->signing_key_cert == NULL) {
  1212. log_warn(LD_REND, "Unable to create descriptor signing certificate for "
  1213. "service %s",
  1214. safe_str_client(service->onion_address));
  1215. goto end;
  1216. }
  1217. /* Copy public key material to go in the descriptor. */
  1218. ed25519_pubkey_copy(&plaintext->signing_pubkey, &desc->signing_kp.pubkey);
  1219. ed25519_pubkey_copy(&plaintext->blinded_pubkey, &desc->blinded_kp.pubkey);
  1220. /* Success. */
  1221. ret = 0;
  1222. end:
  1223. return ret;
  1224. }
  1225. /** Compute the descriptor's OPE cipher for encrypting revision counters. */
  1226. static crypto_ope_t *
  1227. generate_ope_cipher_for_desc(const hs_service_descriptor_t *hs_desc)
  1228. {
  1229. /* Compute OPE key as H("rev-counter-generation" | blinded privkey) */
  1230. uint8_t key[DIGEST256_LEN];
  1231. crypto_digest_t *digest = crypto_digest256_new(DIGEST_SHA3_256);
  1232. const char ope_key_prefix[] = "rev-counter-generation";
  1233. const ed25519_secret_key_t *eph_privkey = &hs_desc->blinded_kp.seckey;
  1234. crypto_digest_add_bytes(digest, ope_key_prefix, sizeof(ope_key_prefix));
  1235. crypto_digest_add_bytes(digest, (char*)eph_privkey->seckey,
  1236. sizeof(eph_privkey->seckey));
  1237. crypto_digest_get_digest(digest, (char *)key, sizeof(key));
  1238. crypto_digest_free(digest);
  1239. return crypto_ope_new(key);
  1240. }
  1241. /* For the given service and descriptor object, create the key material which
  1242. * is the blinded keypair and the descriptor signing keypair. Return 0 on
  1243. * success else -1 on error where the generated keys MUST be ignored. */
  1244. static int
  1245. build_service_desc_keys(const hs_service_t *service,
  1246. hs_service_descriptor_t *desc)
  1247. {
  1248. int ret = 0;
  1249. ed25519_keypair_t kp;
  1250. tor_assert(desc);
  1251. tor_assert(!tor_mem_is_zero((char *) &service->keys.identity_pk,
  1252. ED25519_PUBKEY_LEN));
  1253. /* XXX: Support offline key feature (#18098). */
  1254. /* Copy the identity keys to the keypair so we can use it to create the
  1255. * blinded key. */
  1256. memcpy(&kp.pubkey, &service->keys.identity_pk, sizeof(kp.pubkey));
  1257. memcpy(&kp.seckey, &service->keys.identity_sk, sizeof(kp.seckey));
  1258. /* Build blinded keypair for this time period. */
  1259. hs_build_blinded_keypair(&kp, NULL, 0, desc->time_period_num,
  1260. &desc->blinded_kp);
  1261. /* Let's not keep too much traces of our keys in memory. */
  1262. memwipe(&kp, 0, sizeof(kp));
  1263. /* Compute the OPE cipher struct (it's tied to the current blinded key) */
  1264. log_info(LD_GENERAL,
  1265. "Getting OPE for TP#%u", (unsigned) desc->time_period_num);
  1266. tor_assert_nonfatal(!desc->ope_cipher);
  1267. desc->ope_cipher = generate_ope_cipher_for_desc(desc);
  1268. /* No need for extra strong, this is a temporary key only for this
  1269. * descriptor. Nothing long term. */
  1270. if (ed25519_keypair_generate(&desc->signing_kp, 0) < 0) {
  1271. log_warn(LD_REND, "Can't generate descriptor signing keypair for "
  1272. "service %s",
  1273. safe_str_client(service->onion_address));
  1274. ret = -1;
  1275. }
  1276. return ret;
  1277. }
  1278. /* Given a service and the current time, build a descriptor for the service.
  1279. * This function does not pick introduction point, this needs to be done by
  1280. * the update function. On success, desc_out will point to the newly allocated
  1281. * descriptor object.
  1282. *
  1283. * This can error if we are unable to create keys or certificate. */
  1284. static void
  1285. build_service_descriptor(hs_service_t *service, time_t now,
  1286. uint64_t time_period_num,
  1287. hs_service_descriptor_t **desc_out)
  1288. {
  1289. char *encoded_desc;
  1290. hs_service_descriptor_t *desc;
  1291. tor_assert(service);
  1292. tor_assert(desc_out);
  1293. desc = service_descriptor_new();
  1294. /* Set current time period */
  1295. desc->time_period_num = time_period_num;
  1296. /* Create the needed keys so we can setup the descriptor content. */
  1297. if (build_service_desc_keys(service, desc) < 0) {
  1298. goto err;
  1299. }
  1300. /* Setup plaintext descriptor content. */
  1301. if (build_service_desc_plaintext(service, desc, now) < 0) {
  1302. goto err;
  1303. }
  1304. /* Setup encrypted descriptor content. */
  1305. if (build_service_desc_encrypted(service, desc) < 0) {
  1306. goto err;
  1307. }
  1308. /* Let's make sure that we've created a descriptor that can actually be
  1309. * encoded properly. This function also checks if the encoded output is
  1310. * decodable after. */
  1311. if (BUG(hs_desc_encode_descriptor(desc->desc, &desc->signing_kp,
  1312. &encoded_desc) < 0)) {
  1313. goto err;
  1314. }
  1315. tor_free(encoded_desc);
  1316. /* Assign newly built descriptor to the next slot. */
  1317. *desc_out = desc;
  1318. /* Fire a CREATED control port event. */
  1319. hs_control_desc_event_created(service->onion_address,
  1320. &desc->blinded_kp.pubkey);
  1321. return;
  1322. err:
  1323. service_descriptor_free(desc);
  1324. }
  1325. /* Build both descriptors for the given service that has just booted up.
  1326. * Because it's a special case, it deserves its special function ;). */
  1327. static void
  1328. build_descriptors_for_new_service(hs_service_t *service, time_t now)
  1329. {
  1330. uint64_t current_desc_tp, next_desc_tp;
  1331. tor_assert(service);
  1332. /* These are the conditions for a new service. */
  1333. tor_assert(!service->desc_current);
  1334. tor_assert(!service->desc_next);
  1335. /*
  1336. * +------------------------------------------------------------------+
  1337. * | |
  1338. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1339. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1340. * | |
  1341. * | $==========|-----------$===========|-----------$===========| |
  1342. * | ^ ^ |
  1343. * | A B |
  1344. * +------------------------------------------------------------------+
  1345. *
  1346. * Case A: The service boots up before a new time period, the current time
  1347. * period is thus TP#1 and the next is TP#2 which for both we have access to
  1348. * their SRVs.
  1349. *
  1350. * Case B: The service boots up inside TP#2, we can't use the TP#3 for the
  1351. * next descriptor because we don't have the SRV#3 so the current should be
  1352. * TP#1 and next TP#2.
  1353. */
  1354. if (hs_in_period_between_tp_and_srv(NULL, now)) {
  1355. /* Case B from the above, inside of the new time period. */
  1356. current_desc_tp = hs_get_previous_time_period_num(0); /* TP#1 */
  1357. next_desc_tp = hs_get_time_period_num(0); /* TP#2 */
  1358. } else {
  1359. /* Case A from the above, outside of the new time period. */
  1360. current_desc_tp = hs_get_time_period_num(0); /* TP#1 */
  1361. next_desc_tp = hs_get_next_time_period_num(0); /* TP#2 */
  1362. }
  1363. /* Build descriptors. */
  1364. build_service_descriptor(service, now, current_desc_tp,
  1365. &service->desc_current);
  1366. build_service_descriptor(service, now, next_desc_tp,
  1367. &service->desc_next);
  1368. log_info(LD_REND, "Hidden service %s has just started. Both descriptors "
  1369. "built. Now scheduled for upload.",
  1370. safe_str_client(service->onion_address));
  1371. }
  1372. /* Build descriptors for each service if needed. There are conditions to build
  1373. * a descriptor which are details in the function. */
  1374. STATIC void
  1375. build_all_descriptors(time_t now)
  1376. {
  1377. FOR_EACH_SERVICE_BEGIN(service) {
  1378. /* A service booting up will have both descriptors to NULL. No other cases
  1379. * makes both descriptor non existent. */
  1380. if (service->desc_current == NULL && service->desc_next == NULL) {
  1381. build_descriptors_for_new_service(service, now);
  1382. continue;
  1383. }
  1384. /* Reaching this point means we are pass bootup so at runtime. We should
  1385. * *never* have an empty current descriptor. If the next descriptor is
  1386. * empty, we'll try to build it for the next time period. This only
  1387. * happens when we rotate meaning that we are guaranteed to have a new SRV
  1388. * at that point for the next time period. */
  1389. if (BUG(service->desc_current == NULL)) {
  1390. continue;
  1391. }
  1392. if (service->desc_next == NULL) {
  1393. build_service_descriptor(service, now, hs_get_next_time_period_num(0),
  1394. &service->desc_next);
  1395. log_info(LD_REND, "Hidden service %s next descriptor successfully "
  1396. "built. Now scheduled for upload.",
  1397. safe_str_client(service->onion_address));
  1398. }
  1399. } FOR_EACH_DESCRIPTOR_END;
  1400. }
  1401. /* Randomly pick a node to become an introduction point but not present in the
  1402. * given exclude_nodes list. The chosen node is put in the exclude list
  1403. * regardless of success or not because in case of failure, the node is simply
  1404. * unsusable from that point on.
  1405. *
  1406. * If direct_conn is set, try to pick a node that our local firewall/policy
  1407. * allows us to connect to directly. If we can't find any, return NULL.
  1408. * This function supports selecting dual-stack nodes for direct single onion
  1409. * service IPv6 connections. But it does not send IPv6 addresses in link
  1410. * specifiers. (Current clients don't use IPv6 addresses to extend, and
  1411. * direct client connections to intro points are not supported.)
  1412. *
  1413. * Return a newly allocated service intro point ready to be used for encoding.
  1414. * Return NULL on error. */
  1415. static hs_service_intro_point_t *
  1416. pick_intro_point(unsigned int direct_conn, smartlist_t *exclude_nodes)
  1417. {
  1418. const node_t *node;
  1419. extend_info_t *info = NULL;
  1420. hs_service_intro_point_t *ip = NULL;
  1421. /* Normal 3-hop introduction point flags. */
  1422. router_crn_flags_t flags = CRN_NEED_UPTIME | CRN_NEED_DESC;
  1423. /* Single onion flags. */
  1424. router_crn_flags_t direct_flags = flags | CRN_PREF_ADDR | CRN_DIRECT_CONN;
  1425. node = router_choose_random_node(exclude_nodes, get_options()->ExcludeNodes,
  1426. direct_conn ? direct_flags : flags);
  1427. /* Unable to find a node. When looking for a node for a direct connection,
  1428. * we could try a 3-hop path instead. We'll add support for this in a later
  1429. * release. */
  1430. if (!node) {
  1431. goto err;
  1432. }
  1433. /* We have a suitable node, add it to the exclude list. We do this *before*
  1434. * we can validate the extend information because even in case of failure,
  1435. * we don't want to use that node anymore. */
  1436. smartlist_add(exclude_nodes, (void *) node);
  1437. /* We do this to ease our life but also this call makes appropriate checks
  1438. * of the node object such as validating ntor support for instance.
  1439. *
  1440. * We must provide an extend_info for clients to connect over a 3-hop path,
  1441. * so we don't pass direct_conn here. */
  1442. info = extend_info_from_node(node, 0);
  1443. if (BUG(info == NULL)) {
  1444. goto err;
  1445. }
  1446. /* Let's do a basic sanity check here so that we don't end up advertising the
  1447. * ed25519 identity key of relays that don't actually support the link
  1448. * protocol */
  1449. if (!node_supports_ed25519_link_authentication(node, 0)) {
  1450. tor_assert_nonfatal(ed25519_public_key_is_zero(&info->ed_identity));
  1451. } else {
  1452. /* Make sure we *do* have an ed key if we support the link authentication.
  1453. * Sending an empty key would result in a failure to extend. */
  1454. tor_assert_nonfatal(!ed25519_public_key_is_zero(&info->ed_identity));
  1455. }
  1456. /* Create our objects and populate them with the node information.
  1457. * We don't care if the intro's link auth is compatible with us, because
  1458. * we are sending the ed25519 key to a remote client via the descriptor. */
  1459. ip = service_intro_point_new(info, !node_supports_ed25519_hs_intro(node),
  1460. node_supports_ed25519_link_authentication(node,
  1461. 0));
  1462. if (ip == NULL) {
  1463. goto err;
  1464. }
  1465. log_info(LD_REND, "Picked intro point: %s", extend_info_describe(info));
  1466. extend_info_free(info);
  1467. return ip;
  1468. err:
  1469. service_intro_point_free(ip);
  1470. extend_info_free(info);
  1471. return NULL;
  1472. }
  1473. /* For a given descriptor from the given service, pick any needed intro points
  1474. * and update the current map with those newly picked intro points. Return the
  1475. * number node that might have been added to the descriptor current map. */
  1476. static unsigned int
  1477. pick_needed_intro_points(hs_service_t *service,
  1478. hs_service_descriptor_t *desc)
  1479. {
  1480. int i = 0, num_needed_ip;
  1481. smartlist_t *exclude_nodes = smartlist_new();
  1482. tor_assert(service);
  1483. tor_assert(desc);
  1484. /* Compute how many intro points we actually need to open. */
  1485. num_needed_ip = service->config.num_intro_points -
  1486. digest256map_size(desc->intro_points.map);
  1487. if (BUG(num_needed_ip < 0)) {
  1488. /* Let's not make tor freak out here and just skip this. */
  1489. goto done;
  1490. }
  1491. /* We want to end up with config.num_intro_points intro points, but if we
  1492. * have no intro points at all (chances are they all cycled or we are
  1493. * starting up), we launch get_intro_point_num_extra() extra circuits and
  1494. * use the first config.num_intro_points that complete. See proposal #155,
  1495. * section 4 for the rationale of this which is purely for performance.
  1496. *
  1497. * The ones after the first config.num_intro_points will be converted to
  1498. * 'General' internal circuits and then we'll drop them from the list of
  1499. * intro points. */
  1500. if (digest256map_size(desc->intro_points.map) == 0) {
  1501. num_needed_ip += get_intro_point_num_extra();
  1502. }
  1503. /* Build an exclude list of nodes of our intro point(s). The expiring intro
  1504. * points are OK to pick again because this is afterall a concept of round
  1505. * robin so they are considered valid nodes to pick again. */
  1506. DIGEST256MAP_FOREACH(desc->intro_points.map, key,
  1507. hs_service_intro_point_t *, ip) {
  1508. const node_t *intro_node = get_node_from_intro_point(ip);
  1509. if (intro_node) {
  1510. smartlist_add(exclude_nodes, (void*)intro_node);
  1511. }
  1512. } DIGEST256MAP_FOREACH_END;
  1513. /* Also, add the failing intro points that our descriptor encounteered in
  1514. * the exclude node list. */
  1515. setup_intro_point_exclude_list(desc, exclude_nodes);
  1516. for (i = 0; i < num_needed_ip; i++) {
  1517. hs_service_intro_point_t *ip;
  1518. /* This function will add the picked intro point node to the exclude nodes
  1519. * list so we don't pick the same one at the next iteration. */
  1520. ip = pick_intro_point(service->config.is_single_onion, exclude_nodes);
  1521. if (ip == NULL) {
  1522. /* If we end up unable to pick an introduction point it is because we
  1523. * can't find suitable node and calling this again is highly unlikely to
  1524. * give us a valid node all of the sudden. */
  1525. log_info(LD_REND, "Unable to find a suitable node to be an "
  1526. "introduction point for service %s.",
  1527. safe_str_client(service->onion_address));
  1528. goto done;
  1529. }
  1530. /* Valid intro point object, add it to the descriptor current map. */
  1531. service_intro_point_add(desc->intro_points.map, ip);
  1532. }
  1533. /* We've successfully picked all our needed intro points thus none are
  1534. * missing which will tell our upload process to expect the number of
  1535. * circuits to be the number of configured intro points circuits and not the
  1536. * number of intro points object that we have. */
  1537. desc->missing_intro_points = 0;
  1538. /* Success. */
  1539. done:
  1540. /* We don't have ownership of the node_t object in this list. */
  1541. smartlist_free(exclude_nodes);
  1542. return i;
  1543. }
  1544. /** Clear previous cached HSDirs in <b>desc</b>. */
  1545. static void
  1546. service_desc_clear_previous_hsdirs(hs_service_descriptor_t *desc)
  1547. {
  1548. if (BUG(!desc->previous_hsdirs)) {
  1549. return;
  1550. }
  1551. SMARTLIST_FOREACH(desc->previous_hsdirs, char*, s, tor_free(s));
  1552. smartlist_clear(desc->previous_hsdirs);
  1553. }
  1554. /** Note that we attempted to upload <b>desc</b> to <b>hsdir</b>. */
  1555. static void
  1556. service_desc_note_upload(hs_service_descriptor_t *desc, const node_t *hsdir)
  1557. {
  1558. char b64_digest[BASE64_DIGEST_LEN+1] = {0};
  1559. digest_to_base64(b64_digest, hsdir->identity);
  1560. if (BUG(!desc->previous_hsdirs)) {
  1561. return;
  1562. }
  1563. if (!smartlist_contains_string(desc->previous_hsdirs, b64_digest)) {
  1564. smartlist_add_strdup(desc->previous_hsdirs, b64_digest);
  1565. }
  1566. }
  1567. /** Schedule an upload of <b>desc</b>. If <b>descriptor_changed</b> is set, it
  1568. * means that this descriptor is dirty. */
  1569. STATIC void
  1570. service_desc_schedule_upload(hs_service_descriptor_t *desc,
  1571. time_t now,
  1572. int descriptor_changed)
  1573. {
  1574. desc->next_upload_time = now;
  1575. /* If the descriptor changed, clean up the old HSDirs list. We want to
  1576. * re-upload no matter what. */
  1577. if (descriptor_changed) {
  1578. service_desc_clear_previous_hsdirs(desc);
  1579. }
  1580. }
  1581. /* Update the given descriptor from the given service. The possible update
  1582. * actions includes:
  1583. * - Picking missing intro points if needed.
  1584. */
  1585. static void
  1586. update_service_descriptor(hs_service_t *service,
  1587. hs_service_descriptor_t *desc, time_t now)
  1588. {
  1589. unsigned int num_intro_points;
  1590. tor_assert(service);
  1591. tor_assert(desc);
  1592. tor_assert(desc->desc);
  1593. num_intro_points = digest256map_size(desc->intro_points.map);
  1594. /* Pick any missing introduction point(s). */
  1595. if (num_intro_points < service->config.num_intro_points) {
  1596. unsigned int num_new_intro_points = pick_needed_intro_points(service,
  1597. desc);
  1598. if (num_new_intro_points != 0) {
  1599. log_info(LD_REND, "Service %s just picked %u intro points and wanted "
  1600. "%u for %s descriptor. It currently has %d intro "
  1601. "points. Launching ESTABLISH_INTRO circuit shortly.",
  1602. safe_str_client(service->onion_address),
  1603. num_new_intro_points,
  1604. service->config.num_intro_points - num_intro_points,
  1605. (desc == service->desc_current) ? "current" : "next",
  1606. num_intro_points);
  1607. /* We'll build those introduction point into the descriptor once we have
  1608. * confirmation that the circuits are opened and ready. However,
  1609. * indicate that this descriptor should be uploaded from now on. */
  1610. service_desc_schedule_upload(desc, now, 1);
  1611. }
  1612. /* Were we able to pick all the intro points we needed? If not, we'll
  1613. * flag the descriptor that it's missing intro points because it
  1614. * couldn't pick enough which will trigger a descriptor upload. */
  1615. if ((num_new_intro_points + num_intro_points) <
  1616. service->config.num_intro_points) {
  1617. desc->missing_intro_points = 1;
  1618. }
  1619. }
  1620. }
  1621. /* Update descriptors for each service if needed. */
  1622. STATIC void
  1623. update_all_descriptors(time_t now)
  1624. {
  1625. FOR_EACH_SERVICE_BEGIN(service) {
  1626. /* We'll try to update each descriptor that is if certain conditions apply
  1627. * in order for the descriptor to be updated. */
  1628. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  1629. update_service_descriptor(service, desc, now);
  1630. } FOR_EACH_DESCRIPTOR_END;
  1631. } FOR_EACH_SERVICE_END;
  1632. }
  1633. /* Return true iff the given intro point has expired that is it has been used
  1634. * for too long or we've reached our max seen INTRODUCE2 cell. */
  1635. STATIC int
  1636. intro_point_should_expire(const hs_service_intro_point_t *ip,
  1637. time_t now)
  1638. {
  1639. tor_assert(ip);
  1640. if (ip->introduce2_count >= ip->introduce2_max) {
  1641. goto expired;
  1642. }
  1643. if (ip->time_to_expire <= now) {
  1644. goto expired;
  1645. }
  1646. /* Not expiring. */
  1647. return 0;
  1648. expired:
  1649. return 1;
  1650. }
  1651. /* Go over the given set of intro points for each service and remove any
  1652. * invalid ones. The conditions for removal are:
  1653. *
  1654. * - The node doesn't exists anymore (not in consensus)
  1655. * OR
  1656. * - The intro point maximum circuit retry count has been reached and no
  1657. * circuit can be found associated with it.
  1658. * OR
  1659. * - The intro point has expired and we should pick a new one.
  1660. *
  1661. * If an intro point is removed, the circuit (if any) is immediately close.
  1662. * If a circuit can't be found, the intro point is kept if it hasn't reached
  1663. * its maximum circuit retry value and thus should be retried. */
  1664. static void
  1665. cleanup_intro_points(hs_service_t *service, time_t now)
  1666. {
  1667. /* List of intro points to close. We can't mark the intro circuits for close
  1668. * in the modify loop because doing so calls
  1669. * hs_service_intro_circ_has_closed() which does a digest256map_get() on the
  1670. * intro points map (that we are iterating over). This can't be done in a
  1671. * single iteration after a MAP_DEL_CURRENT, the object will still be
  1672. * returned leading to a use-after-free. So, we close the circuits and free
  1673. * the intro points after the loop if any. */
  1674. smartlist_t *ips_to_free = smartlist_new();
  1675. tor_assert(service);
  1676. /* For both descriptors, cleanup the intro points. */
  1677. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  1678. /* Go over the current intro points we have, make sure they are still
  1679. * valid and remove any of them that aren't. */
  1680. DIGEST256MAP_FOREACH_MODIFY(desc->intro_points.map, key,
  1681. hs_service_intro_point_t *, ip) {
  1682. const node_t *node = get_node_from_intro_point(ip);
  1683. int has_expired = intro_point_should_expire(ip, now);
  1684. /* We cleanup an intro point if it has expired or if we do not know the
  1685. * node_t anymore (removed from our latest consensus) or if we've
  1686. * reached the maximum number of retry with a non existing circuit. */
  1687. if (has_expired || node == NULL ||
  1688. ip->circuit_retries > MAX_INTRO_POINT_CIRCUIT_RETRIES) {
  1689. log_info(LD_REND, "Intro point %s%s (retried: %u times). "
  1690. "Removing it.",
  1691. describe_intro_point(ip),
  1692. has_expired ? " has expired" :
  1693. (node == NULL) ? " fell off the consensus" : "",
  1694. ip->circuit_retries);
  1695. /* We've retried too many times, remember it as a failed intro point
  1696. * so we don't pick it up again for INTRO_CIRC_RETRY_PERIOD sec. */
  1697. if (ip->circuit_retries > MAX_INTRO_POINT_CIRCUIT_RETRIES) {
  1698. remember_failing_intro_point(ip, desc, approx_time());
  1699. }
  1700. /* Remove intro point from descriptor map and add it to the list of
  1701. * ips to free for which we'll also try to close the intro circuit. */
  1702. MAP_DEL_CURRENT(key);
  1703. smartlist_add(ips_to_free, ip);
  1704. }
  1705. } DIGEST256MAP_FOREACH_END;
  1706. } FOR_EACH_DESCRIPTOR_END;
  1707. /* Go over the intro points to free and close their circuit if any. */
  1708. SMARTLIST_FOREACH_BEGIN(ips_to_free, hs_service_intro_point_t *, ip) {
  1709. /* See if we need to close the intro point circuit as well */
  1710. /* XXX: Legacy code does NOT close circuits like this: it keeps the circuit
  1711. * open until a new descriptor is uploaded and then closed all expiring
  1712. * intro point circuit. Here, we close immediately and because we just
  1713. * discarded the intro point, a new one will be selected, a new descriptor
  1714. * created and uploaded. There is no difference to an attacker between the
  1715. * timing of a new consensus and intro point rotation (possibly?). */
  1716. origin_circuit_t *ocirc = hs_circ_service_get_intro_circ(ip);
  1717. if (ocirc && !TO_CIRCUIT(ocirc)->marked_for_close) {
  1718. circuit_mark_for_close(TO_CIRCUIT(ocirc), END_CIRC_REASON_FINISHED);
  1719. }
  1720. /* Cleanup the intro point */
  1721. service_intro_point_free(ip);
  1722. } SMARTLIST_FOREACH_END(ip);
  1723. smartlist_free(ips_to_free);
  1724. }
  1725. /* Set the next rotation time of the descriptors for the given service for the
  1726. * time now. */
  1727. static void
  1728. set_rotation_time(hs_service_t *service)
  1729. {
  1730. tor_assert(service);
  1731. service->state.next_rotation_time =
  1732. sr_state_get_start_time_of_current_protocol_run() +
  1733. sr_state_get_protocol_run_duration();
  1734. {
  1735. char fmt_time[ISO_TIME_LEN + 1];
  1736. format_local_iso_time(fmt_time, service->state.next_rotation_time);
  1737. log_info(LD_REND, "Next descriptor rotation time set to %s for %s",
  1738. fmt_time, safe_str_client(service->onion_address));
  1739. }
  1740. }
  1741. /* Return true iff the service should rotate its descriptor. The time now is
  1742. * only used to fetch the live consensus and if none can be found, this
  1743. * returns false. */
  1744. static unsigned int
  1745. should_rotate_descriptors(hs_service_t *service, time_t now)
  1746. {
  1747. const networkstatus_t *ns;
  1748. tor_assert(service);
  1749. ns = networkstatus_get_live_consensus(now);
  1750. if (ns == NULL) {
  1751. goto no_rotation;
  1752. }
  1753. if (ns->valid_after >= service->state.next_rotation_time) {
  1754. /* In theory, we should never get here with no descriptors. We can never
  1755. * have a NULL current descriptor except when tor starts up. The next
  1756. * descriptor can be NULL after a rotation but we build a new one right
  1757. * after.
  1758. *
  1759. * So, when tor starts, the next rotation time is set to the start of the
  1760. * next SRV period using the consensus valid after time so it should
  1761. * always be set to a future time value. This means that we should never
  1762. * reach this point at bootup that is this check safeguards tor in never
  1763. * allowing a rotation if the valid after time is smaller than the next
  1764. * rotation time.
  1765. *
  1766. * This is all good in theory but we've had a NULL descriptor issue here
  1767. * so this is why we BUG() on both with extra logging to try to understand
  1768. * how this can possibly happens. We'll simply ignore and tor should
  1769. * recover from this by skipping rotation and building the missing
  1770. * descriptors just after this. */
  1771. if (BUG(service->desc_current == NULL || service->desc_next == NULL)) {
  1772. log_warn(LD_BUG, "Service descriptor is NULL (%p/%p). Next rotation "
  1773. "time is %ld (now: %ld). Valid after time from "
  1774. "consensus is %ld",
  1775. service->desc_current, service->desc_next,
  1776. (long)service->state.next_rotation_time,
  1777. (long)now,
  1778. (long)ns->valid_after);
  1779. goto no_rotation;
  1780. }
  1781. goto rotation;
  1782. }
  1783. no_rotation:
  1784. return 0;
  1785. rotation:
  1786. return 1;
  1787. }
  1788. /* Rotate the service descriptors of the given service. The current descriptor
  1789. * will be freed, the next one put in as the current and finally the next
  1790. * descriptor pointer is NULLified. */
  1791. static void
  1792. rotate_service_descriptors(hs_service_t *service)
  1793. {
  1794. if (service->desc_current) {
  1795. /* Close all IP circuits for the descriptor. */
  1796. close_intro_circuits(&service->desc_current->intro_points);
  1797. /* We don't need this one anymore, we won't serve any clients coming with
  1798. * this service descriptor. */
  1799. service_descriptor_free(service->desc_current);
  1800. }
  1801. /* The next one become the current one and emptying the next will trigger
  1802. * a descriptor creation for it. */
  1803. service->desc_current = service->desc_next;
  1804. service->desc_next = NULL;
  1805. /* We've just rotated, set the next time for the rotation. */
  1806. set_rotation_time(service);
  1807. }
  1808. /* Rotate descriptors for each service if needed. A non existing current
  1809. * descriptor will trigger a descriptor build for the next time period. */
  1810. STATIC void
  1811. rotate_all_descriptors(time_t now)
  1812. {
  1813. /* XXX We rotate all our service descriptors at once. In the future it might
  1814. * be wise, to rotate service descriptors independently to hide that all
  1815. * those descriptors are on the same tor instance */
  1816. FOR_EACH_SERVICE_BEGIN(service) {
  1817. /* Note for a service booting up: Both descriptors are NULL in that case
  1818. * so this function might return true if we are in the timeframe for a
  1819. * rotation leading to basically swapping two NULL pointers which is
  1820. * harmless. However, the side effect is that triggering a rotation will
  1821. * update the service state and avoid doing anymore rotations after the
  1822. * two descriptors have been built. */
  1823. if (!should_rotate_descriptors(service, now)) {
  1824. continue;
  1825. }
  1826. log_info(LD_REND, "Time to rotate our descriptors (%p / %p) for %s",
  1827. service->desc_current, service->desc_next,
  1828. safe_str_client(service->onion_address));
  1829. rotate_service_descriptors(service);
  1830. } FOR_EACH_SERVICE_END;
  1831. }
  1832. /* Scheduled event run from the main loop. Make sure all our services are up
  1833. * to date and ready for the other scheduled events. This includes looking at
  1834. * the introduction points status and descriptor rotation time. */
  1835. STATIC void
  1836. run_housekeeping_event(time_t now)
  1837. {
  1838. /* Note that nothing here opens circuit(s) nor uploads descriptor(s). We are
  1839. * simply moving things around or removing unneeded elements. */
  1840. FOR_EACH_SERVICE_BEGIN(service) {
  1841. /* If the service is starting off, set the rotation time. We can't do that
  1842. * at configure time because the get_options() needs to be set for setting
  1843. * that time that uses the voting interval. */
  1844. if (service->state.next_rotation_time == 0) {
  1845. /* Set the next rotation time of the descriptors. If it's Oct 25th
  1846. * 23:47:00, the next rotation time is when the next SRV is computed
  1847. * which is at Oct 26th 00:00:00 that is in 13 minutes. */
  1848. set_rotation_time(service);
  1849. }
  1850. /* Cleanup invalid intro points from the service descriptor. */
  1851. cleanup_intro_points(service, now);
  1852. /* Remove expired failing intro point from the descriptor failed list. We
  1853. * reset them at each INTRO_CIRC_RETRY_PERIOD. */
  1854. remove_expired_failing_intro(service, now);
  1855. /* At this point, the service is now ready to go through the scheduled
  1856. * events guaranteeing a valid state. Intro points might be missing from
  1857. * the descriptors after the cleanup but the update/build process will
  1858. * make sure we pick those missing ones. */
  1859. } FOR_EACH_SERVICE_END;
  1860. }
  1861. /* Scheduled event run from the main loop. Make sure all descriptors are up to
  1862. * date. Once this returns, each service descriptor needs to be considered for
  1863. * new introduction circuits and then for upload. */
  1864. static void
  1865. run_build_descriptor_event(time_t now)
  1866. {
  1867. /* For v2 services, this step happens in the upload event. */
  1868. /* Run v3+ events. */
  1869. /* We start by rotating the descriptors only if needed. */
  1870. rotate_all_descriptors(now);
  1871. /* Then, we'll try to build new descriptors that we might need. The
  1872. * condition is that the next descriptor is non existing because it has
  1873. * been rotated or we just started up. */
  1874. build_all_descriptors(now);
  1875. /* Finally, we'll check if we should update the descriptors. Missing
  1876. * introduction points will be picked in this function which is useful for
  1877. * newly built descriptors. */
  1878. update_all_descriptors(now);
  1879. }
  1880. /* For the given service, launch any intro point circuits that could be
  1881. * needed. This considers every descriptor of the service. */
  1882. static void
  1883. launch_intro_point_circuits(hs_service_t *service)
  1884. {
  1885. tor_assert(service);
  1886. /* For both descriptors, try to launch any missing introduction point
  1887. * circuits using the current map. */
  1888. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  1889. /* Keep a ref on if we need a direct connection. We use this often. */
  1890. unsigned int direct_conn = service->config.is_single_onion;
  1891. DIGEST256MAP_FOREACH_MODIFY(desc->intro_points.map, key,
  1892. hs_service_intro_point_t *, ip) {
  1893. extend_info_t *ei;
  1894. /* Skip the intro point that already has an existing circuit
  1895. * (established or not). */
  1896. if (hs_circ_service_get_intro_circ(ip)) {
  1897. continue;
  1898. }
  1899. ei = get_extend_info_from_intro_point(ip, direct_conn);
  1900. if (ei == NULL) {
  1901. /* This is possible if we can get a node_t but not the extend info out
  1902. * of it. In this case, we remove the intro point and a new one will
  1903. * be picked at the next main loop callback. */
  1904. MAP_DEL_CURRENT(key);
  1905. service_intro_point_free(ip);
  1906. continue;
  1907. }
  1908. /* Launch a circuit to the intro point. */
  1909. ip->circuit_retries++;
  1910. if (hs_circ_launch_intro_point(service, ip, ei) < 0) {
  1911. log_info(LD_REND, "Unable to launch intro circuit to node %s "
  1912. "for service %s.",
  1913. safe_str_client(extend_info_describe(ei)),
  1914. safe_str_client(service->onion_address));
  1915. /* Intro point will be retried if possible after this. */
  1916. }
  1917. extend_info_free(ei);
  1918. } DIGEST256MAP_FOREACH_END;
  1919. } FOR_EACH_DESCRIPTOR_END;
  1920. }
  1921. /* Don't try to build more than this many circuits before giving up for a
  1922. * while. Dynamically calculated based on the configured number of intro
  1923. * points for the given service and how many descriptor exists. The default
  1924. * use case of 3 introduction points and two descriptors will allow 28
  1925. * circuits for a retry period (((3 + 2) + (3 * 3)) * 2). */
  1926. static unsigned int
  1927. get_max_intro_circ_per_period(const hs_service_t *service)
  1928. {
  1929. unsigned int count = 0;
  1930. unsigned int multiplier = 0;
  1931. unsigned int num_wanted_ip;
  1932. tor_assert(service);
  1933. tor_assert(service->config.num_intro_points <=
  1934. HS_CONFIG_V3_MAX_INTRO_POINTS);
  1935. /* For a testing network, allow to do it for the maximum amount so circuit
  1936. * creation and rotation and so on can actually be tested without limit. */
  1937. #define MAX_INTRO_POINT_CIRCUIT_RETRIES_TESTING -1
  1938. if (get_options()->TestingTorNetwork) {
  1939. return MAX_INTRO_POINT_CIRCUIT_RETRIES_TESTING;
  1940. }
  1941. num_wanted_ip = service->config.num_intro_points;
  1942. /* The calculation is as follow. We have a number of intro points that we
  1943. * want configured as a torrc option (num_intro_points). We then add an
  1944. * extra value so we can launch multiple circuits at once and pick the
  1945. * quickest ones. For instance, we want 3 intros, we add 2 extra so we'll
  1946. * pick 5 intros and launch 5 circuits. */
  1947. count += (num_wanted_ip + get_intro_point_num_extra());
  1948. /* Then we add the number of retries that is possible to do for each intro
  1949. * point. If we want 3 intros, we'll allow 3 times the number of possible
  1950. * retry. */
  1951. count += (num_wanted_ip * MAX_INTRO_POINT_CIRCUIT_RETRIES);
  1952. /* Then, we multiply by a factor of 2 if we have both descriptor or 0 if we
  1953. * have none. */
  1954. multiplier += (service->desc_current) ? 1 : 0;
  1955. multiplier += (service->desc_next) ? 1 : 0;
  1956. return (count * multiplier);
  1957. }
  1958. /* For the given service, return 1 if the service is allowed to launch more
  1959. * introduction circuits else 0 if the maximum has been reached for the retry
  1960. * period of INTRO_CIRC_RETRY_PERIOD. */
  1961. STATIC int
  1962. can_service_launch_intro_circuit(hs_service_t *service, time_t now)
  1963. {
  1964. tor_assert(service);
  1965. /* Consider the intro circuit retry period of the service. */
  1966. if (now > (service->state.intro_circ_retry_started_time +
  1967. INTRO_CIRC_RETRY_PERIOD)) {
  1968. service->state.intro_circ_retry_started_time = now;
  1969. service->state.num_intro_circ_launched = 0;
  1970. goto allow;
  1971. }
  1972. /* Check if we can still launch more circuits in this period. */
  1973. if (service->state.num_intro_circ_launched <=
  1974. get_max_intro_circ_per_period(service)) {
  1975. goto allow;
  1976. }
  1977. /* Rate limit log that we've reached our circuit creation limit. */
  1978. {
  1979. char *msg;
  1980. time_t elapsed_time = now - service->state.intro_circ_retry_started_time;
  1981. static ratelim_t rlimit = RATELIM_INIT(INTRO_CIRC_RETRY_PERIOD);
  1982. if ((msg = rate_limit_log(&rlimit, now))) {
  1983. log_info(LD_REND, "Hidden service %s exceeded its circuit launch limit "
  1984. "of %u per %d seconds. It launched %u circuits in "
  1985. "the last %ld seconds. Will retry in %ld seconds.",
  1986. safe_str_client(service->onion_address),
  1987. get_max_intro_circ_per_period(service),
  1988. INTRO_CIRC_RETRY_PERIOD,
  1989. service->state.num_intro_circ_launched,
  1990. (long int) elapsed_time,
  1991. (long int) (INTRO_CIRC_RETRY_PERIOD - elapsed_time));
  1992. tor_free(msg);
  1993. }
  1994. }
  1995. /* Not allow. */
  1996. return 0;
  1997. allow:
  1998. return 1;
  1999. }
  2000. /* Scheduled event run from the main loop. Make sure we have all the circuits
  2001. * we need for each service. */
  2002. static void
  2003. run_build_circuit_event(time_t now)
  2004. {
  2005. /* Make sure we can actually have enough information or able to build
  2006. * internal circuits as required by services. */
  2007. if (router_have_consensus_path() == CONSENSUS_PATH_UNKNOWN ||
  2008. !have_completed_a_circuit()) {
  2009. return;
  2010. }
  2011. /* Run v2 check. */
  2012. if (rend_num_services() > 0) {
  2013. rend_consider_services_intro_points(now);
  2014. }
  2015. /* Run v3+ check. */
  2016. FOR_EACH_SERVICE_BEGIN(service) {
  2017. /* For introduction circuit, we need to make sure we don't stress too much
  2018. * circuit creation so make sure this service is respecting that limit. */
  2019. if (can_service_launch_intro_circuit(service, now)) {
  2020. /* Launch intro point circuits if needed. */
  2021. launch_intro_point_circuits(service);
  2022. /* Once the circuits have opened, we'll make sure to update the
  2023. * descriptor intro point list and cleanup any extraneous. */
  2024. }
  2025. } FOR_EACH_SERVICE_END;
  2026. }
  2027. /* Encode and sign the service descriptor desc and upload it to the given
  2028. * hidden service directory. This does nothing if PublishHidServDescriptors
  2029. * is false. */
  2030. static void
  2031. upload_descriptor_to_hsdir(const hs_service_t *service,
  2032. hs_service_descriptor_t *desc, const node_t *hsdir)
  2033. {
  2034. char *encoded_desc = NULL;
  2035. tor_assert(service);
  2036. tor_assert(desc);
  2037. tor_assert(hsdir);
  2038. /* Let's avoid doing that if tor is configured to not publish. */
  2039. if (!get_options()->PublishHidServDescriptors) {
  2040. log_info(LD_REND, "Service %s not publishing descriptor. "
  2041. "PublishHidServDescriptors is set to 1.",
  2042. safe_str_client(service->onion_address));
  2043. goto end;
  2044. }
  2045. /* First of all, we'll encode the descriptor. This should NEVER fail but
  2046. * just in case, let's make sure we have an actual usable descriptor. */
  2047. if (BUG(hs_desc_encode_descriptor(desc->desc, &desc->signing_kp,
  2048. &encoded_desc) < 0)) {
  2049. goto end;
  2050. }
  2051. /* Time to upload the descriptor to the directory. */
  2052. hs_service_upload_desc_to_dir(encoded_desc, service->config.version,
  2053. &service->keys.identity_pk,
  2054. &desc->blinded_kp.pubkey, hsdir->rs);
  2055. /* Add this node to previous_hsdirs list */
  2056. service_desc_note_upload(desc, hsdir);
  2057. /* Logging so we know where it was sent. */
  2058. {
  2059. int is_next_desc = (service->desc_next == desc);
  2060. const uint8_t *idx = (is_next_desc) ? hsdir->hsdir_index.store_second:
  2061. hsdir->hsdir_index.store_first;
  2062. char *blinded_pubkey_log_str =
  2063. tor_strdup(hex_str((char*)&desc->blinded_kp.pubkey.pubkey, 32));
  2064. log_info(LD_REND, "Service %s %s descriptor of revision %" PRIu64
  2065. " initiated upload request to %s with index %s (%s)",
  2066. safe_str_client(service->onion_address),
  2067. (is_next_desc) ? "next" : "current",
  2068. desc->desc->plaintext_data.revision_counter,
  2069. safe_str_client(node_describe(hsdir)),
  2070. safe_str_client(hex_str((const char *) idx, 32)),
  2071. safe_str_client(blinded_pubkey_log_str));
  2072. tor_free(blinded_pubkey_log_str);
  2073. /* Fire a UPLOAD control port event. */
  2074. hs_control_desc_event_upload(service->onion_address, hsdir->identity,
  2075. &desc->blinded_kp.pubkey, idx);
  2076. }
  2077. end:
  2078. tor_free(encoded_desc);
  2079. return;
  2080. }
  2081. /** Set the revision counter in <b>hs_desc</b>. We do this by encrypting a
  2082. * timestamp using an OPE scheme and using the ciphertext as our revision
  2083. * counter.
  2084. *
  2085. * If <b>is_current</b> is true, then this is the current HS descriptor,
  2086. * otherwise it's the next one. */
  2087. static void
  2088. set_descriptor_revision_counter(hs_service_descriptor_t *hs_desc, time_t now,
  2089. bool is_current)
  2090. {
  2091. uint64_t rev_counter = 0;
  2092. /* Get current time */
  2093. time_t srv_start = 0;
  2094. /* As our revision counter plaintext value, we use the seconds since the
  2095. * start of the SR protocol run that is relevant to this descriptor. This is
  2096. * guaranteed to be a positive value since we need the SRV to start making a
  2097. * descriptor (so that we know where to upload it).
  2098. *
  2099. * Depending on whether we are building the current or the next descriptor,
  2100. * services use a different SRV value. See [SERVICEUPLOAD] in
  2101. * rend-spec-v3.txt:
  2102. *
  2103. * In particular, for the current descriptor (aka first descriptor), Tor
  2104. * always uses the previous SRV for uploading the descriptor, and hence we
  2105. * should use the start time of the previous protocol run here.
  2106. *
  2107. * Whereas for the next descriptor (aka second descriptor), Tor always uses
  2108. * the current SRV for uploading the descriptor. and hence we use the start
  2109. * time of the current protocol run.
  2110. */
  2111. if (is_current) {
  2112. srv_start = sr_state_get_start_time_of_previous_protocol_run();
  2113. } else {
  2114. srv_start = sr_state_get_start_time_of_current_protocol_run();
  2115. }
  2116. log_info(LD_REND, "Setting rev counter for TP #%u: "
  2117. "SRV started at %d, now %d (%s)",
  2118. (unsigned) hs_desc->time_period_num, (int)srv_start,
  2119. (int)now, is_current ? "current" : "next");
  2120. tor_assert_nonfatal(now >= srv_start);
  2121. /* Compute seconds elapsed since the start of the time period. That's the
  2122. * number of seconds of how long this blinded key has been active. */
  2123. time_t seconds_since_start_of_srv = now - srv_start;
  2124. /* Increment by one so that we are definitely sure this is strictly
  2125. * positive and not zero. */
  2126. seconds_since_start_of_srv++;
  2127. /* Check for too big inputs. */
  2128. if (BUG(seconds_since_start_of_srv > OPE_INPUT_MAX)) {
  2129. seconds_since_start_of_srv = OPE_INPUT_MAX;
  2130. }
  2131. /* Now we compute the final revision counter value by encrypting the
  2132. plaintext using our OPE cipher: */
  2133. tor_assert(hs_desc->ope_cipher);
  2134. rev_counter = crypto_ope_encrypt(hs_desc->ope_cipher,
  2135. (int) seconds_since_start_of_srv);
  2136. /* The OPE module returns CRYPTO_OPE_ERROR in case of errors. */
  2137. tor_assert_nonfatal(rev_counter < CRYPTO_OPE_ERROR);
  2138. log_info(LD_REND, "Encrypted revision counter %d to %ld",
  2139. (int) seconds_since_start_of_srv, (long int) rev_counter);
  2140. hs_desc->desc->plaintext_data.revision_counter = rev_counter;
  2141. }
  2142. /* Encode and sign the service descriptor desc and upload it to the
  2143. * responsible hidden service directories. If for_next_period is true, the set
  2144. * of directories are selected using the next hsdir_index. This does nothing
  2145. * if PublishHidServDescriptors is false. */
  2146. STATIC void
  2147. upload_descriptor_to_all(const hs_service_t *service,
  2148. hs_service_descriptor_t *desc)
  2149. {
  2150. smartlist_t *responsible_dirs = NULL;
  2151. tor_assert(service);
  2152. tor_assert(desc);
  2153. /* We'll first cancel any directory request that are ongoing for this
  2154. * descriptor. It is possible that we can trigger multiple uploads in a
  2155. * short time frame which can lead to a race where the second upload arrives
  2156. * before the first one leading to a 400 malformed descriptor response from
  2157. * the directory. Closing all pending requests avoids that. */
  2158. close_directory_connections(service, desc);
  2159. /* Get our list of responsible HSDir. */
  2160. responsible_dirs = smartlist_new();
  2161. /* The parameter 0 means that we aren't a client so tell the function to use
  2162. * the spread store consensus paremeter. */
  2163. hs_get_responsible_hsdirs(&desc->blinded_kp.pubkey, desc->time_period_num,
  2164. service->desc_next == desc, 0, responsible_dirs);
  2165. /** Clear list of previous hsdirs since we are about to upload to a new
  2166. * list. Let's keep it up to date. */
  2167. service_desc_clear_previous_hsdirs(desc);
  2168. /* For each responsible HSDir we have, initiate an upload command. */
  2169. SMARTLIST_FOREACH_BEGIN(responsible_dirs, const routerstatus_t *,
  2170. hsdir_rs) {
  2171. const node_t *hsdir_node = node_get_by_id(hsdir_rs->identity_digest);
  2172. /* Getting responsible hsdir implies that the node_t object exists for the
  2173. * routerstatus_t found in the consensus else we have a problem. */
  2174. tor_assert(hsdir_node);
  2175. /* Upload this descriptor to the chosen directory. */
  2176. upload_descriptor_to_hsdir(service, desc, hsdir_node);
  2177. } SMARTLIST_FOREACH_END(hsdir_rs);
  2178. /* Set the next upload time for this descriptor. Even if we are configured
  2179. * to not upload, we still want to follow the right cycle of life for this
  2180. * descriptor. */
  2181. desc->next_upload_time =
  2182. (time(NULL) + crypto_rand_int_range(HS_SERVICE_NEXT_UPLOAD_TIME_MIN,
  2183. HS_SERVICE_NEXT_UPLOAD_TIME_MAX));
  2184. {
  2185. char fmt_next_time[ISO_TIME_LEN+1];
  2186. format_local_iso_time(fmt_next_time, desc->next_upload_time);
  2187. log_debug(LD_REND, "Service %s set to upload a descriptor at %s",
  2188. safe_str_client(service->onion_address), fmt_next_time);
  2189. }
  2190. smartlist_free(responsible_dirs);
  2191. return;
  2192. }
  2193. /** The set of HSDirs have changed: check if the change affects our descriptor
  2194. * HSDir placement, and if it does, reupload the desc. */
  2195. STATIC int
  2196. service_desc_hsdirs_changed(const hs_service_t *service,
  2197. const hs_service_descriptor_t *desc)
  2198. {
  2199. int should_reupload = 0;
  2200. smartlist_t *responsible_dirs = smartlist_new();
  2201. /* No desc upload has happened yet: it will happen eventually */
  2202. if (!desc->previous_hsdirs || !smartlist_len(desc->previous_hsdirs)) {
  2203. goto done;
  2204. }
  2205. /* Get list of responsible hsdirs */
  2206. hs_get_responsible_hsdirs(&desc->blinded_kp.pubkey, desc->time_period_num,
  2207. service->desc_next == desc, 0, responsible_dirs);
  2208. /* Check if any new hsdirs have been added to the responsible hsdirs set:
  2209. * Iterate over the list of new hsdirs, and reupload if any of them is not
  2210. * present in the list of previous hsdirs.
  2211. */
  2212. SMARTLIST_FOREACH_BEGIN(responsible_dirs, const routerstatus_t *, hsdir_rs) {
  2213. char b64_digest[BASE64_DIGEST_LEN+1] = {0};
  2214. digest_to_base64(b64_digest, hsdir_rs->identity_digest);
  2215. if (!smartlist_contains_string(desc->previous_hsdirs, b64_digest)) {
  2216. should_reupload = 1;
  2217. break;
  2218. }
  2219. } SMARTLIST_FOREACH_END(hsdir_rs);
  2220. done:
  2221. smartlist_free(responsible_dirs);
  2222. return should_reupload;
  2223. }
  2224. /* Return 1 if the given descriptor from the given service can be uploaded
  2225. * else return 0 if it can not. */
  2226. static int
  2227. should_service_upload_descriptor(const hs_service_t *service,
  2228. const hs_service_descriptor_t *desc, time_t now)
  2229. {
  2230. unsigned int num_intro_points;
  2231. tor_assert(service);
  2232. tor_assert(desc);
  2233. /* If this descriptors has missing intro points that is that it couldn't get
  2234. * them all when it was time to pick them, it means that we should upload
  2235. * instead of waiting an arbitrary amount of time breaking the service.
  2236. * Else, if we have no missing intro points, we use the value taken from the
  2237. * service configuration. */
  2238. if (desc->missing_intro_points) {
  2239. num_intro_points = digest256map_size(desc->intro_points.map);
  2240. } else {
  2241. num_intro_points = service->config.num_intro_points;
  2242. }
  2243. /* This means we tried to pick intro points but couldn't get any so do not
  2244. * upload descriptor in this case. We need at least one for the service to
  2245. * be reachable. */
  2246. if (desc->missing_intro_points && num_intro_points == 0) {
  2247. goto cannot;
  2248. }
  2249. /* Check if all our introduction circuit have been established for all the
  2250. * intro points we have selected. */
  2251. if (count_desc_circuit_established(desc) != num_intro_points) {
  2252. goto cannot;
  2253. }
  2254. /* Is it the right time to upload? */
  2255. if (desc->next_upload_time > now) {
  2256. goto cannot;
  2257. }
  2258. /* Don't upload desc if we don't have a live consensus */
  2259. if (!networkstatus_get_live_consensus(now)) {
  2260. goto cannot;
  2261. }
  2262. /* Do we know enough router descriptors to have adequate vision of the HSDir
  2263. hash ring? */
  2264. if (!router_have_minimum_dir_info()) {
  2265. goto cannot;
  2266. }
  2267. /* Can upload! */
  2268. return 1;
  2269. cannot:
  2270. return 0;
  2271. }
  2272. /* Scheduled event run from the main loop. Try to upload the descriptor for
  2273. * each service. */
  2274. STATIC void
  2275. run_upload_descriptor_event(time_t now)
  2276. {
  2277. /* v2 services use the same function for descriptor creation and upload so
  2278. * we do everything here because the intro circuits were checked before. */
  2279. if (rend_num_services() > 0) {
  2280. rend_consider_services_upload(now);
  2281. rend_consider_descriptor_republication();
  2282. }
  2283. /* Run v3+ check. */
  2284. FOR_EACH_SERVICE_BEGIN(service) {
  2285. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  2286. /* If we were asked to re-examine the hash ring, and it changed, then
  2287. schedule an upload */
  2288. if (consider_republishing_hs_descriptors &&
  2289. service_desc_hsdirs_changed(service, desc)) {
  2290. service_desc_schedule_upload(desc, now, 0);
  2291. }
  2292. /* Can this descriptor be uploaded? */
  2293. if (!should_service_upload_descriptor(service, desc, now)) {
  2294. continue;
  2295. }
  2296. log_info(LD_REND, "Initiating upload for hidden service %s descriptor "
  2297. "for service %s with %u/%u introduction points%s.",
  2298. (desc == service->desc_current) ? "current" : "next",
  2299. safe_str_client(service->onion_address),
  2300. digest256map_size(desc->intro_points.map),
  2301. service->config.num_intro_points,
  2302. (desc->missing_intro_points) ? " (couldn't pick more)" : "");
  2303. /* At this point, we have to upload the descriptor so start by building
  2304. * the intro points descriptor section which we are now sure to be
  2305. * accurate because all circuits have been established. */
  2306. build_desc_intro_points(service, desc, now);
  2307. /* Set the desc revision counter right before uploading */
  2308. set_descriptor_revision_counter(desc, approx_time(),
  2309. service->desc_current == desc);
  2310. upload_descriptor_to_all(service, desc);
  2311. } FOR_EACH_DESCRIPTOR_END;
  2312. } FOR_EACH_SERVICE_END;
  2313. /* We are done considering whether to republish rend descriptors */
  2314. consider_republishing_hs_descriptors = 0;
  2315. }
  2316. /* Called when the introduction point circuit is done building and ready to be
  2317. * used. */
  2318. static void
  2319. service_intro_circ_has_opened(origin_circuit_t *circ)
  2320. {
  2321. hs_service_t *service = NULL;
  2322. hs_service_intro_point_t *ip = NULL;
  2323. hs_service_descriptor_t *desc = NULL;
  2324. tor_assert(circ);
  2325. /* Let's do some basic sanity checking of the circ state */
  2326. if (BUG(!circ->cpath)) {
  2327. return;
  2328. }
  2329. if (BUG(TO_CIRCUIT(circ)->purpose != CIRCUIT_PURPOSE_S_ESTABLISH_INTRO)) {
  2330. return;
  2331. }
  2332. if (BUG(!circ->hs_ident)) {
  2333. return;
  2334. }
  2335. /* Get the corresponding service and intro point. */
  2336. get_objects_from_ident(circ->hs_ident, &service, &ip, &desc);
  2337. if (service == NULL) {
  2338. log_warn(LD_REND, "Unknown service identity key %s on the introduction "
  2339. "circuit %u. Can't find onion service.",
  2340. safe_str_client(ed25519_fmt(&circ->hs_ident->identity_pk)),
  2341. TO_CIRCUIT(circ)->n_circ_id);
  2342. goto err;
  2343. }
  2344. if (ip == NULL) {
  2345. log_warn(LD_REND, "Unknown introduction point auth key on circuit %u "
  2346. "for service %s",
  2347. TO_CIRCUIT(circ)->n_circ_id,
  2348. safe_str_client(service->onion_address));
  2349. goto err;
  2350. }
  2351. /* We can't have an IP object without a descriptor. */
  2352. tor_assert(desc);
  2353. if (hs_circ_service_intro_has_opened(service, ip, desc, circ)) {
  2354. /* Getting here means that the circuit has been re-purposed because we
  2355. * have enough intro circuit opened. Remove the IP from the service. */
  2356. service_intro_point_remove(service, ip);
  2357. service_intro_point_free(ip);
  2358. }
  2359. goto done;
  2360. err:
  2361. /* Close circuit, we can't use it. */
  2362. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_NOSUCHSERVICE);
  2363. done:
  2364. return;
  2365. }
  2366. /* Called when a rendezvous circuit is done building and ready to be used. */
  2367. static void
  2368. service_rendezvous_circ_has_opened(origin_circuit_t *circ)
  2369. {
  2370. hs_service_t *service = NULL;
  2371. tor_assert(circ);
  2372. tor_assert(circ->cpath);
  2373. /* Getting here means this is a v3 rendezvous circuit. */
  2374. tor_assert(circ->hs_ident);
  2375. tor_assert(TO_CIRCUIT(circ)->purpose == CIRCUIT_PURPOSE_S_CONNECT_REND);
  2376. /* Declare the circuit dirty to avoid reuse, and for path-bias. We set the
  2377. * timestamp regardless of its content because that circuit could have been
  2378. * cannibalized so in any cases, we are about to use that circuit more. */
  2379. TO_CIRCUIT(circ)->timestamp_dirty = time(NULL);
  2380. pathbias_count_use_attempt(circ);
  2381. /* Get the corresponding service and intro point. */
  2382. get_objects_from_ident(circ->hs_ident, &service, NULL, NULL);
  2383. if (service == NULL) {
  2384. log_warn(LD_REND, "Unknown service identity key %s on the rendezvous "
  2385. "circuit %u with cookie %s. Can't find onion service.",
  2386. safe_str_client(ed25519_fmt(&circ->hs_ident->identity_pk)),
  2387. TO_CIRCUIT(circ)->n_circ_id,
  2388. hex_str((const char *) circ->hs_ident->rendezvous_cookie,
  2389. REND_COOKIE_LEN));
  2390. goto err;
  2391. }
  2392. /* If the cell can't be sent, the circuit will be closed within this
  2393. * function. */
  2394. hs_circ_service_rp_has_opened(service, circ);
  2395. goto done;
  2396. err:
  2397. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_NOSUCHSERVICE);
  2398. done:
  2399. return;
  2400. }
  2401. /* We've been expecting an INTRO_ESTABLISHED cell on this circuit and it just
  2402. * arrived. Handle the INTRO_ESTABLISHED cell arriving on the given
  2403. * introduction circuit. Return 0 on success else a negative value. */
  2404. static int
  2405. service_handle_intro_established(origin_circuit_t *circ,
  2406. const uint8_t *payload,
  2407. size_t payload_len)
  2408. {
  2409. hs_service_t *service = NULL;
  2410. hs_service_intro_point_t *ip = NULL;
  2411. tor_assert(circ);
  2412. tor_assert(payload);
  2413. tor_assert(TO_CIRCUIT(circ)->purpose == CIRCUIT_PURPOSE_S_ESTABLISH_INTRO);
  2414. /* We need the service and intro point for this cell. */
  2415. get_objects_from_ident(circ->hs_ident, &service, &ip, NULL);
  2416. /* Get service object from the circuit identifier. */
  2417. if (service == NULL) {
  2418. log_warn(LD_REND, "Unknown service identity key %s on the introduction "
  2419. "circuit %u. Can't find onion service.",
  2420. safe_str_client(ed25519_fmt(&circ->hs_ident->identity_pk)),
  2421. TO_CIRCUIT(circ)->n_circ_id);
  2422. goto err;
  2423. }
  2424. if (ip == NULL) {
  2425. /* We don't recognize the key. */
  2426. log_warn(LD_REND, "Introduction circuit established without an intro "
  2427. "point object on circuit %u for service %s",
  2428. TO_CIRCUIT(circ)->n_circ_id,
  2429. safe_str_client(service->onion_address));
  2430. goto err;
  2431. }
  2432. /* Try to parse the payload into a cell making sure we do actually have a
  2433. * valid cell. On success, the ip object and circuit purpose is updated to
  2434. * reflect the fact that the introduction circuit is established. */
  2435. if (hs_circ_handle_intro_established(service, ip, circ, payload,
  2436. payload_len) < 0) {
  2437. goto err;
  2438. }
  2439. /* Flag that we have an established circuit for this intro point. This value
  2440. * is what indicates the upload scheduled event if we are ready to build the
  2441. * intro point into the descriptor and upload. */
  2442. ip->circuit_established = 1;
  2443. log_info(LD_REND, "Successfully received an INTRO_ESTABLISHED cell "
  2444. "on circuit %u for service %s",
  2445. TO_CIRCUIT(circ)->n_circ_id,
  2446. safe_str_client(service->onion_address));
  2447. return 0;
  2448. err:
  2449. return -1;
  2450. }
  2451. /* We just received an INTRODUCE2 cell on the established introduction circuit
  2452. * circ. Handle the cell and return 0 on success else a negative value. */
  2453. static int
  2454. service_handle_introduce2(origin_circuit_t *circ, const uint8_t *payload,
  2455. size_t payload_len)
  2456. {
  2457. hs_service_t *service = NULL;
  2458. hs_service_intro_point_t *ip = NULL;
  2459. hs_service_descriptor_t *desc = NULL;
  2460. tor_assert(circ);
  2461. tor_assert(payload);
  2462. tor_assert(TO_CIRCUIT(circ)->purpose == CIRCUIT_PURPOSE_S_INTRO);
  2463. /* We'll need every object associated with this circuit. */
  2464. get_objects_from_ident(circ->hs_ident, &service, &ip, &desc);
  2465. /* Get service object from the circuit identifier. */
  2466. if (service == NULL) {
  2467. log_warn(LD_BUG, "Unknown service identity key %s when handling "
  2468. "an INTRODUCE2 cell on circuit %u",
  2469. safe_str_client(ed25519_fmt(&circ->hs_ident->identity_pk)),
  2470. TO_CIRCUIT(circ)->n_circ_id);
  2471. goto err;
  2472. }
  2473. if (ip == NULL) {
  2474. /* We don't recognize the key. */
  2475. log_warn(LD_BUG, "Unknown introduction auth key when handling "
  2476. "an INTRODUCE2 cell on circuit %u for service %s",
  2477. TO_CIRCUIT(circ)->n_circ_id,
  2478. safe_str_client(service->onion_address));
  2479. goto err;
  2480. }
  2481. /* If we have an IP object, we MUST have a descriptor object. */
  2482. tor_assert(desc);
  2483. /* The following will parse, decode and launch the rendezvous point circuit.
  2484. * Both current and legacy cells are handled. */
  2485. if (hs_circ_handle_introduce2(service, circ, ip, desc->desc->subcredential,
  2486. payload, payload_len) < 0) {
  2487. goto err;
  2488. }
  2489. return 0;
  2490. err:
  2491. return -1;
  2492. }
  2493. /* Add to list every filename used by service. This is used by the sandbox
  2494. * subsystem. */
  2495. static void
  2496. service_add_fnames_to_list(const hs_service_t *service, smartlist_t *list)
  2497. {
  2498. const char *s_dir;
  2499. char fname[128] = {0};
  2500. tor_assert(service);
  2501. tor_assert(list);
  2502. /* Ease our life. */
  2503. s_dir = service->config.directory_path;
  2504. /* The hostname file. */
  2505. smartlist_add(list, hs_path_from_filename(s_dir, fname_hostname));
  2506. /* The key files splitted in two. */
  2507. tor_snprintf(fname, sizeof(fname), "%s_secret_key", fname_keyfile_prefix);
  2508. smartlist_add(list, hs_path_from_filename(s_dir, fname));
  2509. tor_snprintf(fname, sizeof(fname), "%s_public_key", fname_keyfile_prefix);
  2510. smartlist_add(list, hs_path_from_filename(s_dir, fname));
  2511. }
  2512. /* Return true iff the given service identity key is present on disk. */
  2513. static int
  2514. service_key_on_disk(const char *directory_path)
  2515. {
  2516. int ret = 0;
  2517. char *fname;
  2518. ed25519_keypair_t *kp = NULL;
  2519. tor_assert(directory_path);
  2520. /* Build the v3 key path name and then try to load it. */
  2521. fname = hs_path_from_filename(directory_path, fname_keyfile_prefix);
  2522. kp = ed_key_init_from_file(fname, INIT_ED_KEY_SPLIT,
  2523. LOG_DEBUG, NULL, 0, 0, 0, NULL, NULL);
  2524. if (kp) {
  2525. ret = 1;
  2526. }
  2527. ed25519_keypair_free(kp);
  2528. tor_free(fname);
  2529. return ret;
  2530. }
  2531. /* ========== */
  2532. /* Public API */
  2533. /* ========== */
  2534. /* This is called everytime the service map (v2 or v3) changes that is if an
  2535. * element is added or removed. */
  2536. void
  2537. hs_service_map_has_changed(void)
  2538. {
  2539. /* If we now have services where previously we had not, we need to enable
  2540. * the HS service main loop event. If we changed to having no services, we
  2541. * need to disable the event. */
  2542. rescan_periodic_events(get_options());
  2543. }
  2544. /* Upload an encoded descriptor in encoded_desc of the given version. This
  2545. * descriptor is for the service identity_pk and blinded_pk used to setup the
  2546. * directory connection identifier. It is uploaded to the directory hsdir_rs
  2547. * routerstatus_t object.
  2548. *
  2549. * NOTE: This function does NOT check for PublishHidServDescriptors because it
  2550. * is only used by the control port command HSPOST outside of this subsystem.
  2551. * Inside this code, upload_descriptor_to_hsdir() should be used. */
  2552. void
  2553. hs_service_upload_desc_to_dir(const char *encoded_desc,
  2554. const uint8_t version,
  2555. const ed25519_public_key_t *identity_pk,
  2556. const ed25519_public_key_t *blinded_pk,
  2557. const routerstatus_t *hsdir_rs)
  2558. {
  2559. char version_str[4] = {0};
  2560. directory_request_t *dir_req;
  2561. hs_ident_dir_conn_t ident;
  2562. tor_assert(encoded_desc);
  2563. tor_assert(identity_pk);
  2564. tor_assert(blinded_pk);
  2565. tor_assert(hsdir_rs);
  2566. /* Setup the connection identifier. */
  2567. memset(&ident, 0, sizeof(ident));
  2568. hs_ident_dir_conn_init(identity_pk, blinded_pk, &ident);
  2569. /* This is our resource when uploading which is used to construct the URL
  2570. * with the version number: "/tor/hs/<version>/publish". */
  2571. tor_snprintf(version_str, sizeof(version_str), "%u", version);
  2572. /* Build the directory request for this HSDir. */
  2573. dir_req = directory_request_new(DIR_PURPOSE_UPLOAD_HSDESC);
  2574. directory_request_set_routerstatus(dir_req, hsdir_rs);
  2575. directory_request_set_indirection(dir_req, DIRIND_ANONYMOUS);
  2576. directory_request_set_resource(dir_req, version_str);
  2577. directory_request_set_payload(dir_req, encoded_desc,
  2578. strlen(encoded_desc));
  2579. /* The ident object is copied over the directory connection object once
  2580. * the directory request is initiated. */
  2581. directory_request_upload_set_hs_ident(dir_req, &ident);
  2582. /* Initiate the directory request to the hsdir.*/
  2583. directory_initiate_request(dir_req);
  2584. directory_request_free(dir_req);
  2585. }
  2586. /* Add the ephemeral service using the secret key sk and ports. Both max
  2587. * streams parameter will be set in the newly created service.
  2588. *
  2589. * Ownership of sk and ports is passed to this routine. Regardless of
  2590. * success/failure, callers should not touch these values after calling this
  2591. * routine, and may assume that correct cleanup has been done on failure.
  2592. *
  2593. * Return an appropriate hs_service_add_ephemeral_status_t. */
  2594. hs_service_add_ephemeral_status_t
  2595. hs_service_add_ephemeral(ed25519_secret_key_t *sk, smartlist_t *ports,
  2596. int max_streams_per_rdv_circuit,
  2597. int max_streams_close_circuit, char **address_out)
  2598. {
  2599. hs_service_add_ephemeral_status_t ret;
  2600. hs_service_t *service = NULL;
  2601. tor_assert(sk);
  2602. tor_assert(ports);
  2603. tor_assert(address_out);
  2604. service = hs_service_new(get_options());
  2605. /* Setup the service configuration with specifics. A default service is
  2606. * HS_VERSION_TWO so explicitly set it. */
  2607. service->config.version = HS_VERSION_THREE;
  2608. service->config.max_streams_per_rdv_circuit = max_streams_per_rdv_circuit;
  2609. service->config.max_streams_close_circuit = !!max_streams_close_circuit;
  2610. service->config.is_ephemeral = 1;
  2611. smartlist_free(service->config.ports);
  2612. service->config.ports = ports;
  2613. /* Handle the keys. */
  2614. memcpy(&service->keys.identity_sk, sk, sizeof(service->keys.identity_sk));
  2615. if (ed25519_public_key_generate(&service->keys.identity_pk,
  2616. &service->keys.identity_sk) < 0) {
  2617. log_warn(LD_CONFIG, "Unable to generate ed25519 public key"
  2618. "for v3 service.");
  2619. ret = RSAE_BADPRIVKEY;
  2620. goto err;
  2621. }
  2622. /* Make sure we have at least one port. */
  2623. if (smartlist_len(service->config.ports) == 0) {
  2624. log_warn(LD_CONFIG, "At least one VIRTPORT/TARGET must be specified "
  2625. "for v3 service.");
  2626. ret = RSAE_BADVIRTPORT;
  2627. goto err;
  2628. }
  2629. /* Build the onion address for logging purposes but also the control port
  2630. * uses it for the HS_DESC event. */
  2631. hs_build_address(&service->keys.identity_pk,
  2632. (uint8_t) service->config.version,
  2633. service->onion_address);
  2634. /* The only way the registration can fail is if the service public key
  2635. * already exists. */
  2636. if (BUG(register_service(hs_service_map, service) < 0)) {
  2637. log_warn(LD_CONFIG, "Onion Service private key collides with an "
  2638. "existing v3 service.");
  2639. ret = RSAE_ADDREXISTS;
  2640. goto err;
  2641. }
  2642. log_info(LD_CONFIG, "Added ephemeral v3 onion service: %s",
  2643. safe_str_client(service->onion_address));
  2644. *address_out = tor_strdup(service->onion_address);
  2645. ret = RSAE_OKAY;
  2646. goto end;
  2647. err:
  2648. hs_service_free(service);
  2649. end:
  2650. memwipe(sk, 0, sizeof(ed25519_secret_key_t));
  2651. tor_free(sk);
  2652. return ret;
  2653. }
  2654. /* For the given onion address, delete the ephemeral service. Return 0 on
  2655. * success else -1 on error. */
  2656. int
  2657. hs_service_del_ephemeral(const char *address)
  2658. {
  2659. uint8_t version;
  2660. ed25519_public_key_t pk;
  2661. hs_service_t *service = NULL;
  2662. tor_assert(address);
  2663. if (hs_parse_address(address, &pk, NULL, &version) < 0) {
  2664. log_warn(LD_CONFIG, "Requested malformed v3 onion address for removal.");
  2665. goto err;
  2666. }
  2667. if (version != HS_VERSION_THREE) {
  2668. log_warn(LD_CONFIG, "Requested version of onion address for removal "
  2669. "is not supported.");
  2670. goto err;
  2671. }
  2672. service = find_service(hs_service_map, &pk);
  2673. if (service == NULL) {
  2674. log_warn(LD_CONFIG, "Requested non-existent v3 hidden service for "
  2675. "removal.");
  2676. goto err;
  2677. }
  2678. if (!service->config.is_ephemeral) {
  2679. log_warn(LD_CONFIG, "Requested non-ephemeral v3 hidden service for "
  2680. "removal.");
  2681. goto err;
  2682. }
  2683. /* Close circuits, remove from map and finally free. */
  2684. close_service_circuits(service);
  2685. remove_service(hs_service_map, service);
  2686. hs_service_free(service);
  2687. log_info(LD_CONFIG, "Removed ephemeral v3 hidden service: %s",
  2688. safe_str_client(address));
  2689. return 0;
  2690. err:
  2691. return -1;
  2692. }
  2693. /* Using the ed25519 public key pk, find a service for that key and return the
  2694. * current encoded descriptor as a newly allocated string or NULL if not
  2695. * found. This is used by the control port subsystem. */
  2696. char *
  2697. hs_service_lookup_current_desc(const ed25519_public_key_t *pk)
  2698. {
  2699. const hs_service_t *service;
  2700. tor_assert(pk);
  2701. service = find_service(hs_service_map, pk);
  2702. if (service && service->desc_current) {
  2703. char *encoded_desc = NULL;
  2704. /* No matter what is the result (which should never be a failure), return
  2705. * the encoded variable, if success it will contain the right thing else
  2706. * it will be NULL. */
  2707. hs_desc_encode_descriptor(service->desc_current->desc,
  2708. &service->desc_current->signing_kp,
  2709. &encoded_desc);
  2710. return encoded_desc;
  2711. }
  2712. return NULL;
  2713. }
  2714. /* Return the number of service we have configured and usable. */
  2715. unsigned int
  2716. hs_service_get_num_services(void)
  2717. {
  2718. if (hs_service_map == NULL) {
  2719. return 0;
  2720. }
  2721. return HT_SIZE(hs_service_map);
  2722. }
  2723. /* Called once an introduction circuit is closed. If the circuit doesn't have
  2724. * a v3 identifier, it is ignored. */
  2725. void
  2726. hs_service_intro_circ_has_closed(origin_circuit_t *circ)
  2727. {
  2728. hs_service_t *service = NULL;
  2729. hs_service_intro_point_t *ip = NULL;
  2730. hs_service_descriptor_t *desc = NULL;
  2731. tor_assert(circ);
  2732. if (circ->hs_ident == NULL) {
  2733. /* This is not a v3 circuit, ignore. */
  2734. goto end;
  2735. }
  2736. get_objects_from_ident(circ->hs_ident, &service, &ip, &desc);
  2737. if (service == NULL) {
  2738. /* This is possible if the circuits are closed and the service is
  2739. * immediately deleted. */
  2740. log_info(LD_REND, "Unable to find any hidden service associated "
  2741. "identity key %s on intro circuit %u.",
  2742. ed25519_fmt(&circ->hs_ident->identity_pk),
  2743. TO_CIRCUIT(circ)->n_circ_id);
  2744. goto end;
  2745. }
  2746. if (ip == NULL) {
  2747. /* The introduction point object has already been removed probably by our
  2748. * cleanup process so ignore. */
  2749. goto end;
  2750. }
  2751. /* Can't have an intro point object without a descriptor. */
  2752. tor_assert(desc);
  2753. /* Circuit disappeared so make sure the intro point is updated. By
  2754. * keeping the object in the descriptor, we'll be able to retry. */
  2755. ip->circuit_established = 0;
  2756. end:
  2757. return;
  2758. }
  2759. /* Given conn, a rendezvous edge connection acting as an exit stream, look up
  2760. * the hidden service for the circuit circ, and look up the port and address
  2761. * based on the connection port. Assign the actual connection address.
  2762. *
  2763. * Return 0 on success. Return -1 on failure and the caller should NOT close
  2764. * the circuit. Return -2 on failure and the caller MUST close the circuit for
  2765. * security reasons. */
  2766. int
  2767. hs_service_set_conn_addr_port(const origin_circuit_t *circ,
  2768. edge_connection_t *conn)
  2769. {
  2770. hs_service_t *service = NULL;
  2771. tor_assert(circ);
  2772. tor_assert(conn);
  2773. tor_assert(TO_CIRCUIT(circ)->purpose == CIRCUIT_PURPOSE_S_REND_JOINED);
  2774. tor_assert(circ->hs_ident);
  2775. get_objects_from_ident(circ->hs_ident, &service, NULL, NULL);
  2776. if (service == NULL) {
  2777. log_warn(LD_REND, "Unable to find any hidden service associated "
  2778. "identity key %s on rendezvous circuit %u.",
  2779. ed25519_fmt(&circ->hs_ident->identity_pk),
  2780. TO_CIRCUIT(circ)->n_circ_id);
  2781. /* We want the caller to close the circuit because it's not a valid
  2782. * service so no danger. Attempting to bruteforce the entire key space by
  2783. * opening circuits to learn which service is being hosted here is
  2784. * impractical. */
  2785. goto err_close;
  2786. }
  2787. /* Enforce the streams-per-circuit limit, and refuse to provide a mapping if
  2788. * this circuit will exceed the limit. */
  2789. if (service->config.max_streams_per_rdv_circuit > 0 &&
  2790. (circ->hs_ident->num_rdv_streams >=
  2791. service->config.max_streams_per_rdv_circuit)) {
  2792. #define MAX_STREAM_WARN_INTERVAL 600
  2793. static struct ratelim_t stream_ratelim =
  2794. RATELIM_INIT(MAX_STREAM_WARN_INTERVAL);
  2795. log_fn_ratelim(&stream_ratelim, LOG_WARN, LD_REND,
  2796. "Maximum streams per circuit limit reached on "
  2797. "rendezvous circuit %u for service %s. Circuit has "
  2798. "%" PRIu64 " out of %" PRIu64 " streams. %s.",
  2799. TO_CIRCUIT(circ)->n_circ_id,
  2800. service->onion_address,
  2801. circ->hs_ident->num_rdv_streams,
  2802. service->config.max_streams_per_rdv_circuit,
  2803. service->config.max_streams_close_circuit ?
  2804. "Closing circuit" : "Ignoring open stream request");
  2805. if (service->config.max_streams_close_circuit) {
  2806. /* Service explicitly configured to close immediately. */
  2807. goto err_close;
  2808. }
  2809. /* Exceeding the limit makes tor silently ignore the stream creation
  2810. * request and keep the circuit open. */
  2811. goto err_no_close;
  2812. }
  2813. /* Find a virtual port of that service mathcing the one in the connection if
  2814. * successful, set the address in the connection. */
  2815. if (hs_set_conn_addr_port(service->config.ports, conn) < 0) {
  2816. log_info(LD_REND, "No virtual port mapping exists for port %d for "
  2817. "hidden service %s.",
  2818. TO_CONN(conn)->port, service->onion_address);
  2819. if (service->config.allow_unknown_ports) {
  2820. /* Service explicitly allow connection to unknown ports so close right
  2821. * away because we do not care about port mapping. */
  2822. goto err_close;
  2823. }
  2824. /* If the service didn't explicitly allow it, we do NOT close the circuit
  2825. * here to raise the bar in terms of performance for port mapping. */
  2826. goto err_no_close;
  2827. }
  2828. /* Success. */
  2829. return 0;
  2830. err_close:
  2831. /* Indicate the caller that the circuit should be closed. */
  2832. return -2;
  2833. err_no_close:
  2834. /* Indicate the caller to NOT close the circuit. */
  2835. return -1;
  2836. }
  2837. /* Add to file_list every filename used by a configured hidden service, and to
  2838. * dir_list every directory path used by a configured hidden service. This is
  2839. * used by the sandbox subsystem to whitelist those. */
  2840. void
  2841. hs_service_lists_fnames_for_sandbox(smartlist_t *file_list,
  2842. smartlist_t *dir_list)
  2843. {
  2844. tor_assert(file_list);
  2845. tor_assert(dir_list);
  2846. /* Add files and dirs for legacy services. */
  2847. rend_services_add_filenames_to_lists(file_list, dir_list);
  2848. /* Add files and dirs for v3+. */
  2849. FOR_EACH_SERVICE_BEGIN(service) {
  2850. /* Skip ephemeral service, they don't touch the disk. */
  2851. if (service->config.is_ephemeral) {
  2852. continue;
  2853. }
  2854. service_add_fnames_to_list(service, file_list);
  2855. smartlist_add_strdup(dir_list, service->config.directory_path);
  2856. } FOR_EACH_DESCRIPTOR_END;
  2857. }
  2858. /* Called when our internal view of the directory has changed. We might have
  2859. * received a new batch of descriptors which might affect the shape of the
  2860. * HSDir hash ring. Signal that we should reexamine the hash ring and
  2861. * re-upload our HS descriptors if needed. */
  2862. void
  2863. hs_service_dir_info_changed(void)
  2864. {
  2865. if (hs_service_get_num_services() > 0) {
  2866. /* New directory information usually goes every consensus so rate limit
  2867. * every 30 minutes to not be too conservative. */
  2868. static struct ratelim_t dir_info_changed_ratelim = RATELIM_INIT(30 * 60);
  2869. log_fn_ratelim(&dir_info_changed_ratelim, LOG_INFO, LD_REND,
  2870. "New dirinfo arrived: consider reuploading descriptor");
  2871. consider_republishing_hs_descriptors = 1;
  2872. }
  2873. }
  2874. /* Called when we get an INTRODUCE2 cell on the circ. Respond to the cell and
  2875. * launch a circuit to the rendezvous point. */
  2876. int
  2877. hs_service_receive_introduce2(origin_circuit_t *circ, const uint8_t *payload,
  2878. size_t payload_len)
  2879. {
  2880. int ret = -1;
  2881. tor_assert(circ);
  2882. tor_assert(payload);
  2883. /* Do some initial validation and logging before we parse the cell */
  2884. if (TO_CIRCUIT(circ)->purpose != CIRCUIT_PURPOSE_S_INTRO) {
  2885. log_warn(LD_PROTOCOL, "Received an INTRODUCE2 cell on a "
  2886. "non introduction circuit of purpose %d",
  2887. TO_CIRCUIT(circ)->purpose);
  2888. goto done;
  2889. }
  2890. if (circ->hs_ident) {
  2891. ret = service_handle_introduce2(circ, payload, payload_len);
  2892. hs_stats_note_introduce2_cell(1);
  2893. } else {
  2894. ret = rend_service_receive_introduction(circ, payload, payload_len);
  2895. hs_stats_note_introduce2_cell(0);
  2896. }
  2897. done:
  2898. return ret;
  2899. }
  2900. /* Called when we get an INTRO_ESTABLISHED cell. Mark the circuit as an
  2901. * established introduction point. Return 0 on success else a negative value
  2902. * and the circuit is closed. */
  2903. int
  2904. hs_service_receive_intro_established(origin_circuit_t *circ,
  2905. const uint8_t *payload,
  2906. size_t payload_len)
  2907. {
  2908. int ret = -1;
  2909. tor_assert(circ);
  2910. tor_assert(payload);
  2911. if (TO_CIRCUIT(circ)->purpose != CIRCUIT_PURPOSE_S_ESTABLISH_INTRO) {
  2912. log_warn(LD_PROTOCOL, "Received an INTRO_ESTABLISHED cell on a "
  2913. "non introduction circuit of purpose %d",
  2914. TO_CIRCUIT(circ)->purpose);
  2915. goto err;
  2916. }
  2917. /* Handle both version. v2 uses rend_data and v3 uses the hs circuit
  2918. * identifier hs_ident. Can't be both. */
  2919. if (circ->hs_ident) {
  2920. ret = service_handle_intro_established(circ, payload, payload_len);
  2921. } else {
  2922. ret = rend_service_intro_established(circ, payload, payload_len);
  2923. }
  2924. if (ret < 0) {
  2925. goto err;
  2926. }
  2927. return 0;
  2928. err:
  2929. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  2930. return -1;
  2931. }
  2932. /* Called when any kind of hidden service circuit is done building thus
  2933. * opened. This is the entry point from the circuit subsystem. */
  2934. void
  2935. hs_service_circuit_has_opened(origin_circuit_t *circ)
  2936. {
  2937. tor_assert(circ);
  2938. /* Handle both version. v2 uses rend_data and v3 uses the hs circuit
  2939. * identifier hs_ident. Can't be both. */
  2940. switch (TO_CIRCUIT(circ)->purpose) {
  2941. case CIRCUIT_PURPOSE_S_ESTABLISH_INTRO:
  2942. if (circ->hs_ident) {
  2943. service_intro_circ_has_opened(circ);
  2944. } else {
  2945. rend_service_intro_has_opened(circ);
  2946. }
  2947. break;
  2948. case CIRCUIT_PURPOSE_S_CONNECT_REND:
  2949. if (circ->hs_ident) {
  2950. service_rendezvous_circ_has_opened(circ);
  2951. } else {
  2952. rend_service_rendezvous_has_opened(circ);
  2953. }
  2954. break;
  2955. default:
  2956. tor_assert(0);
  2957. }
  2958. }
  2959. /* Return the service version by looking at the key in the service directory.
  2960. * If the key is not found or unrecognized, -1 is returned. Else, the service
  2961. * version is returned. */
  2962. int
  2963. hs_service_get_version_from_key(const hs_service_t *service)
  2964. {
  2965. int version = -1; /* Unknown version. */
  2966. const char *directory_path;
  2967. tor_assert(service);
  2968. /* We'll try to load the key for version 3. If not found, we'll try version
  2969. * 2 and if not found, we'll send back an unknown version (-1). */
  2970. directory_path = service->config.directory_path;
  2971. /* Version 3 check. */
  2972. if (service_key_on_disk(directory_path)) {
  2973. version = HS_VERSION_THREE;
  2974. goto end;
  2975. }
  2976. /* Version 2 check. */
  2977. if (rend_service_key_on_disk(directory_path)) {
  2978. version = HS_VERSION_TWO;
  2979. goto end;
  2980. }
  2981. end:
  2982. return version;
  2983. }
  2984. /* Load and/or generate keys for all onion services including the client
  2985. * authorization if any. Return 0 on success, -1 on failure. */
  2986. int
  2987. hs_service_load_all_keys(void)
  2988. {
  2989. /* Load v2 service keys if we have v2. */
  2990. if (rend_num_services() != 0) {
  2991. if (rend_service_load_all_keys(NULL) < 0) {
  2992. goto err;
  2993. }
  2994. }
  2995. /* Load or/and generate them for v3+. */
  2996. SMARTLIST_FOREACH_BEGIN(hs_service_staging_list, hs_service_t *, service) {
  2997. /* Ignore ephemeral service, they already have their keys set. */
  2998. if (service->config.is_ephemeral) {
  2999. continue;
  3000. }
  3001. log_info(LD_REND, "Loading v3 onion service keys from %s",
  3002. service_escaped_dir(service));
  3003. if (load_service_keys(service) < 0) {
  3004. goto err;
  3005. }
  3006. /* XXX: Load/Generate client authorization keys. (#20700) */
  3007. } SMARTLIST_FOREACH_END(service);
  3008. /* Final step, the staging list contains service in a quiescent state that
  3009. * is ready to be used. Register them to the global map. Once this is over,
  3010. * the staging list will be cleaned up. */
  3011. register_all_services();
  3012. /* All keys have been loaded successfully. */
  3013. return 0;
  3014. err:
  3015. return -1;
  3016. }
  3017. /* Put all service object in the given service list. After this, the caller
  3018. * looses ownership of every elements in the list and responsible to free the
  3019. * list pointer. */
  3020. void
  3021. hs_service_stage_services(const smartlist_t *service_list)
  3022. {
  3023. tor_assert(service_list);
  3024. /* This list is freed at registration time but this function can be called
  3025. * multiple time. */
  3026. if (hs_service_staging_list == NULL) {
  3027. hs_service_staging_list = smartlist_new();
  3028. }
  3029. /* Add all service object to our staging list. Caller is responsible for
  3030. * freeing the service_list. */
  3031. smartlist_add_all(hs_service_staging_list, service_list);
  3032. }
  3033. /* Allocate and initilize a service object. The service configuration will
  3034. * contain the default values. Return the newly allocated object pointer. This
  3035. * function can't fail. */
  3036. hs_service_t *
  3037. hs_service_new(const or_options_t *options)
  3038. {
  3039. hs_service_t *service = tor_malloc_zero(sizeof(hs_service_t));
  3040. /* Set default configuration value. */
  3041. set_service_default_config(&service->config, options);
  3042. /* Set the default service version. */
  3043. service->config.version = HS_SERVICE_DEFAULT_VERSION;
  3044. /* Allocate the CLIENT_PK replay cache in service state. */
  3045. service->state.replay_cache_rend_cookie =
  3046. replaycache_new(REND_REPLAY_TIME_INTERVAL, REND_REPLAY_TIME_INTERVAL);
  3047. return service;
  3048. }
  3049. /* Free the given <b>service</b> object and all its content. This function
  3050. * also takes care of wiping service keys from memory. It is safe to pass a
  3051. * NULL pointer. */
  3052. void
  3053. hs_service_free_(hs_service_t *service)
  3054. {
  3055. if (service == NULL) {
  3056. return;
  3057. }
  3058. /* Free descriptors. Go over both descriptor with this loop. */
  3059. FOR_EACH_DESCRIPTOR_BEGIN(service, desc) {
  3060. service_descriptor_free(desc);
  3061. } FOR_EACH_DESCRIPTOR_END;
  3062. /* Free service configuration. */
  3063. service_clear_config(&service->config);
  3064. /* Free replay cache from state. */
  3065. if (service->state.replay_cache_rend_cookie) {
  3066. replaycache_free(service->state.replay_cache_rend_cookie);
  3067. }
  3068. /* Wipe service keys. */
  3069. memwipe(&service->keys.identity_sk, 0, sizeof(service->keys.identity_sk));
  3070. tor_free(service);
  3071. }
  3072. /* Periodic callback. Entry point from the main loop to the HS service
  3073. * subsystem. This is call every second. This is skipped if tor can't build a
  3074. * circuit or the network is disabled. */
  3075. void
  3076. hs_service_run_scheduled_events(time_t now)
  3077. {
  3078. /* First thing we'll do here is to make sure our services are in a
  3079. * quiescent state for the scheduled events. */
  3080. run_housekeeping_event(now);
  3081. /* Order matters here. We first make sure the descriptor object for each
  3082. * service contains the latest data. Once done, we check if we need to open
  3083. * new introduction circuit. Finally, we try to upload the descriptor for
  3084. * each service. */
  3085. /* Make sure descriptors are up to date. */
  3086. run_build_descriptor_event(now);
  3087. /* Make sure services have enough circuits. */
  3088. run_build_circuit_event(now);
  3089. /* Upload the descriptors if needed/possible. */
  3090. run_upload_descriptor_event(now);
  3091. }
  3092. /* Initialize the service HS subsystem. */
  3093. void
  3094. hs_service_init(void)
  3095. {
  3096. /* Should never be called twice. */
  3097. tor_assert(!hs_service_map);
  3098. tor_assert(!hs_service_staging_list);
  3099. /* v2 specific. */
  3100. rend_service_init();
  3101. hs_service_map = tor_malloc_zero(sizeof(struct hs_service_ht));
  3102. HT_INIT(hs_service_ht, hs_service_map);
  3103. hs_service_staging_list = smartlist_new();
  3104. }
  3105. /* Release all global storage of the hidden service subsystem. */
  3106. void
  3107. hs_service_free_all(void)
  3108. {
  3109. rend_service_free_all();
  3110. service_free_all();
  3111. }
  3112. #ifdef TOR_UNIT_TESTS
  3113. /* Return the global service map size. Only used by unit test. */
  3114. STATIC unsigned int
  3115. get_hs_service_map_size(void)
  3116. {
  3117. return HT_SIZE(hs_service_map);
  3118. }
  3119. /* Return the staging list size. Only used by unit test. */
  3120. STATIC int
  3121. get_hs_service_staging_list_size(void)
  3122. {
  3123. return smartlist_len(hs_service_staging_list);
  3124. }
  3125. STATIC hs_service_ht *
  3126. get_hs_service_map(void)
  3127. {
  3128. return hs_service_map;
  3129. }
  3130. STATIC hs_service_t *
  3131. get_first_service(void)
  3132. {
  3133. hs_service_t **obj = HT_START(hs_service_ht, hs_service_map);
  3134. if (obj == NULL) {
  3135. return NULL;
  3136. }
  3137. return *obj;
  3138. }
  3139. #endif /* defined(TOR_UNIT_TESTS) */