hs_service.c 126 KB

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