hs_service.c 126 KB

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