hs_service.c 124 KB

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