test_hs.c 40 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993
  1. /* Copyright (c) 2007-2018, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file test_hs.c
  5. * \brief Unit tests for hidden service.
  6. **/
  7. #define CONTROL_PRIVATE
  8. #define CIRCUITBUILD_PRIVATE
  9. #define RENDCOMMON_PRIVATE
  10. #define RENDSERVICE_PRIVATE
  11. #define HS_SERVICE_PRIVATE
  12. #include "core/or/or.h"
  13. #include "test/test.h"
  14. #include "feature/control/control.h"
  15. #include "app/config/config.h"
  16. #include "feature/hs/hs_common.h"
  17. #include "feature/rend/rendcommon.h"
  18. #include "feature/rend/rendservice.h"
  19. #include "feature/nodelist/routerlist.h"
  20. #include "feature/nodelist/routerset.h"
  21. #include "core/or/circuitbuild.h"
  22. #include "feature/nodelist/node_st.h"
  23. #include "feature/rend/rend_encoded_v2_service_descriptor_st.h"
  24. #include "feature/rend/rend_intro_point_st.h"
  25. #include "feature/nodelist/routerinfo_st.h"
  26. #include "test/test_helpers.h"
  27. #ifdef HAVE_UNISTD_H
  28. #include <unistd.h>
  29. #endif
  30. /* mock ID digest and longname for node that's in nodelist */
  31. #define HSDIR_EXIST_ID "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA" \
  32. "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
  33. #define STR_HSDIR_EXIST_LONGNAME \
  34. "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=TestDir"
  35. /* mock ID digest and longname for node that's not in nodelist */
  36. #define HSDIR_NONE_EXIST_ID "\xBB\xBB\xBB\xBB\xBB\xBB\xBB\xBB\xBB\xBB" \
  37. "\xBB\xBB\xBB\xBB\xBB\xBB\xBB\xBB\xBB\xBB"
  38. #define STR_HSDIR_NONE_EXIST_LONGNAME \
  39. "$BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
  40. /* DuckDuckGo descriptor as an example. This one has extra "\r" at the end so
  41. * the control port is happy. */
  42. static const char *hs_desc_content_control = "\
  43. rendezvous-service-descriptor g5ojobzupf275beh5ra72uyhb3dkpxwg\r\n\
  44. version 2\r\n\
  45. permanent-key\r\n\
  46. -----BEGIN RSA PUBLIC KEY-----\r\n\
  47. MIGJAoGBAJ/SzzgrXPxTlFrKVhXh3buCWv2QfcNgncUpDpKouLn3AtPH5Ocys0jE\r\n\
  48. aZSKdvaiQ62md2gOwj4x61cFNdi05tdQjS+2thHKEm/KsB9BGLSLBNJYY356bupg\r\n\
  49. I5gQozM65ENelfxYlysBjJ52xSDBd8C4f/p9umdzaaaCmzXG/nhzAgMBAAE=\r\n\
  50. -----END RSA PUBLIC KEY-----\r\n\
  51. secret-id-part anmjoxxwiupreyajjt5yasimfmwcnxlf\r\n\
  52. publication-time 2015-03-11 19:00:00\r\n\
  53. protocol-versions 2,3\r\n\
  54. introduction-points\r\n\
  55. -----BEGIN MESSAGE-----\r\n\
  56. aW50cm9kdWN0aW9uLXBvaW50IDd1bnd4cmg2dG5kNGh6eWt1Z3EzaGZzdHduc2ll\r\n\
  57. cmhyCmlwLWFkZHJlc3MgMTg4LjEzOC4xMjEuMTE4Cm9uaW9uLXBvcnQgOTAwMQpv\r\n\
  58. bmlvbi1rZXkKLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tCk1JR0pBb0dC\r\n\
  59. QUxGRVVyeVpDbk9ROEhURmV5cDVjMTRObWVqL1BhekFLTTBxRENTNElKUWh0Y3g1\r\n\
  60. NXpRSFdOVWIKQ2hHZ0JqR1RjV3ZGRnA0N3FkdGF6WUZhVXE2c0lQKzVqeWZ5b0Q4\r\n\
  61. UmJ1bzBwQmFWclJjMmNhYUptWWM0RDh6Vgpuby9sZnhzOVVaQnZ1cWY4eHIrMDB2\r\n\
  62. S0JJNmFSMlA2OE1WeDhrMExqcUpUU2RKOE9idm9yQWdNQkFBRT0KLS0tLS1FTkQg\r\n\
  63. UlNBIFBVQkxJQyBLRVktLS0tLQpzZXJ2aWNlLWtleQotLS0tLUJFR0lOIFJTQSBQ\r\n\
  64. VUJMSUMgS0VZLS0tLS0KTUlHSkFvR0JBTnJHb0ozeTlHNXQzN2F2ekI1cTlwN1hG\r\n\
  65. VUplRUVYMUNOaExnWmJXWGJhVk5OcXpoZFhyL0xTUQppM1Z6dW5OaUs3cndUVnE2\r\n\
  66. K2QyZ1lRckhMMmIvMXBBY3ZKWjJiNSs0bTRRc0NibFpjRENXTktRbHJnRWN5WXRJ\r\n\
  67. CkdscXJTbFFEaXA0ZnNrUFMvNDVkWTI0QmJsQ3NGU1k3RzVLVkxJck4zZFpGbmJr\r\n\
  68. NEZIS1hBZ01CQUFFPQotLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tCmludHJv\r\n\
  69. ZHVjdGlvbi1wb2ludCBiNGM3enlxNXNheGZzN2prNXFibG1wN3I1b3pwdHRvagpp\r\n\
  70. cC1hZGRyZXNzIDEwOS4xNjkuNDUuMjI2Cm9uaW9uLXBvcnQgOTAwMQpvbmlvbi1r\r\n\
  71. ZXkKLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tCk1JR0pBb0dCQU8xSXpw\r\n\
  72. WFFUTUY3RXZUb1NEUXpzVnZiRVFRQUQrcGZ6NzczMVRXZzVaUEJZY1EyUkRaeVp4\r\n\
  73. OEQKNUVQSU1FeUE1RE83cGd0ak5LaXJvYXJGMC8yempjMkRXTUlSaXZyU29YUWVZ\r\n\
  74. ZXlMM1pzKzFIajJhMDlCdkYxZAp6MEswblRFdVhoNVR5V3lyMHdsbGI1SFBnTlI0\r\n\
  75. MS9oYkprZzkwZitPVCtIeGhKL1duUml2QWdNQkFBRT0KLS0tLS1FTkQgUlNBIFBV\r\n\
  76. QkxJQyBLRVktLS0tLQpzZXJ2aWNlLWtleQotLS0tLUJFR0lOIFJTQSBQVUJMSUMg\r\n\
  77. S0VZLS0tLS0KTUlHSkFvR0JBSzNWZEJ2ajFtQllLL3JrcHNwcm9Ub0llNUtHVmth\r\n\
  78. QkxvMW1tK1I2YUVJek1VZFE1SjkwNGtyRwpCd3k5NC8rV0lGNFpGYXh5Z2phejl1\r\n\
  79. N2pKY1k3ZGJhd1pFeG1hYXFCRlRwL2h2ZG9rcHQ4a1ByRVk4OTJPRHJ1CmJORUox\r\n\
  80. N1FPSmVMTVZZZk5Kcjl4TWZCQ3JQai8zOGh2RUdrbWVRNmRVWElvbVFNaUJGOVRB\r\n\
  81. Z01CQUFFPQotLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tCmludHJvZHVjdGlv\r\n\
  82. bi1wb2ludCBhdjVtcWl0Y2Q3cjJkandsYmN0c2Jlc2R3eGt0ZWtvegppcC1hZGRy\r\n\
  83. ZXNzIDE0NC43Ni44LjczCm9uaW9uLXBvcnQgNDQzCm9uaW9uLWtleQotLS0tLUJF\r\n\
  84. R0lOIFJTQSBQVUJMSUMgS0VZLS0tLS0KTUlHSkFvR0JBTzVweVZzQmpZQmNmMXBE\r\n\
  85. dklHUlpmWXUzQ05nNldka0ZLMGlvdTBXTGZtejZRVDN0NWhzd3cyVwpjejlHMXhx\r\n\
  86. MmN0Nkd6VWkrNnVkTDlITTRVOUdHTi9BbW8wRG9GV1hKWHpBQkFXd2YyMVdsd1lW\r\n\
  87. eFJQMHRydi9WCkN6UDkzcHc5OG5vSmdGUGRUZ05iMjdKYmVUZENLVFBrTEtscXFt\r\n\
  88. b3NveUN2RitRa25vUS9BZ01CQUFFPQotLS0tLUVORCBSU0EgUFVCTElDIEtFWS0t\r\n\
  89. LS0tCnNlcnZpY2Uta2V5Ci0tLS0tQkVHSU4gUlNBIFBVQkxJQyBLRVktLS0tLQpN\r\n\
  90. SUdKQW9HQkFMVjNKSmtWN3lTNU9jc1lHMHNFYzFQOTVRclFRR3ZzbGJ6Wi9zRGxl\r\n\
  91. RlpKYXFSOUYvYjRUVERNClNGcFMxcU1GbldkZDgxVmRGMEdYRmN2WVpLamRJdHU2\r\n\
  92. SndBaTRJeEhxeXZtdTRKdUxrcXNaTEFLaXRLVkx4eGsKeERlMjlDNzRWMmJrOTRJ\r\n\
  93. MEgybTNKS2tzTHVwc3VxWWRVUmhOVXN0SElKZmgyZmNIalF0bEFnTUJBQUU9Ci0t\r\n\
  94. LS0tRU5EIFJTQSBQVUJMSUMgS0VZLS0tLS0KCg==\r\n\
  95. -----END MESSAGE-----\r\n\
  96. signature\r\n\
  97. -----BEGIN SIGNATURE-----\r\n\
  98. d4OuCE5OLAOnRB6cQN6WyMEmg/BHem144Vec+eYgeWoKwx3MxXFplUjFxgnMlmwN\r\n\
  99. PcftsZf2ztN0sbNCtPgDL3d0PqvxY3iHTQAI8EbaGq/IAJUZ8U4y963dD5+Bn6JQ\r\n\
  100. myE3ctmh0vy5+QxSiRjmQBkuEpCyks7LvWvHYrhnmcg=\r\n\
  101. -----END SIGNATURE-----";
  102. /* DuckDuckGo descriptor as an example. */
  103. static const char *hs_desc_content = "\
  104. rendezvous-service-descriptor g5ojobzupf275beh5ra72uyhb3dkpxwg\n\
  105. version 2\n\
  106. permanent-key\n\
  107. -----BEGIN RSA PUBLIC KEY-----\n\
  108. MIGJAoGBAJ/SzzgrXPxTlFrKVhXh3buCWv2QfcNgncUpDpKouLn3AtPH5Ocys0jE\n\
  109. aZSKdvaiQ62md2gOwj4x61cFNdi05tdQjS+2thHKEm/KsB9BGLSLBNJYY356bupg\n\
  110. I5gQozM65ENelfxYlysBjJ52xSDBd8C4f/p9umdzaaaCmzXG/nhzAgMBAAE=\n\
  111. -----END RSA PUBLIC KEY-----\n\
  112. secret-id-part anmjoxxwiupreyajjt5yasimfmwcnxlf\n\
  113. publication-time 2015-03-11 19:00:00\n\
  114. protocol-versions 2,3\n\
  115. introduction-points\n\
  116. -----BEGIN MESSAGE-----\n\
  117. aW50cm9kdWN0aW9uLXBvaW50IDd1bnd4cmg2dG5kNGh6eWt1Z3EzaGZzdHduc2ll\n\
  118. cmhyCmlwLWFkZHJlc3MgMTg4LjEzOC4xMjEuMTE4Cm9uaW9uLXBvcnQgOTAwMQpv\n\
  119. bmlvbi1rZXkKLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tCk1JR0pBb0dC\n\
  120. QUxGRVVyeVpDbk9ROEhURmV5cDVjMTRObWVqL1BhekFLTTBxRENTNElKUWh0Y3g1\n\
  121. NXpRSFdOVWIKQ2hHZ0JqR1RjV3ZGRnA0N3FkdGF6WUZhVXE2c0lQKzVqeWZ5b0Q4\n\
  122. UmJ1bzBwQmFWclJjMmNhYUptWWM0RDh6Vgpuby9sZnhzOVVaQnZ1cWY4eHIrMDB2\n\
  123. S0JJNmFSMlA2OE1WeDhrMExqcUpUU2RKOE9idm9yQWdNQkFBRT0KLS0tLS1FTkQg\n\
  124. UlNBIFBVQkxJQyBLRVktLS0tLQpzZXJ2aWNlLWtleQotLS0tLUJFR0lOIFJTQSBQ\n\
  125. VUJMSUMgS0VZLS0tLS0KTUlHSkFvR0JBTnJHb0ozeTlHNXQzN2F2ekI1cTlwN1hG\n\
  126. VUplRUVYMUNOaExnWmJXWGJhVk5OcXpoZFhyL0xTUQppM1Z6dW5OaUs3cndUVnE2\n\
  127. K2QyZ1lRckhMMmIvMXBBY3ZKWjJiNSs0bTRRc0NibFpjRENXTktRbHJnRWN5WXRJ\n\
  128. CkdscXJTbFFEaXA0ZnNrUFMvNDVkWTI0QmJsQ3NGU1k3RzVLVkxJck4zZFpGbmJr\n\
  129. NEZIS1hBZ01CQUFFPQotLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tCmludHJv\n\
  130. ZHVjdGlvbi1wb2ludCBiNGM3enlxNXNheGZzN2prNXFibG1wN3I1b3pwdHRvagpp\n\
  131. cC1hZGRyZXNzIDEwOS4xNjkuNDUuMjI2Cm9uaW9uLXBvcnQgOTAwMQpvbmlvbi1r\n\
  132. ZXkKLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tCk1JR0pBb0dCQU8xSXpw\n\
  133. WFFUTUY3RXZUb1NEUXpzVnZiRVFRQUQrcGZ6NzczMVRXZzVaUEJZY1EyUkRaeVp4\n\
  134. OEQKNUVQSU1FeUE1RE83cGd0ak5LaXJvYXJGMC8yempjMkRXTUlSaXZyU29YUWVZ\n\
  135. ZXlMM1pzKzFIajJhMDlCdkYxZAp6MEswblRFdVhoNVR5V3lyMHdsbGI1SFBnTlI0\n\
  136. MS9oYkprZzkwZitPVCtIeGhKL1duUml2QWdNQkFBRT0KLS0tLS1FTkQgUlNBIFBV\n\
  137. QkxJQyBLRVktLS0tLQpzZXJ2aWNlLWtleQotLS0tLUJFR0lOIFJTQSBQVUJMSUMg\n\
  138. S0VZLS0tLS0KTUlHSkFvR0JBSzNWZEJ2ajFtQllLL3JrcHNwcm9Ub0llNUtHVmth\n\
  139. QkxvMW1tK1I2YUVJek1VZFE1SjkwNGtyRwpCd3k5NC8rV0lGNFpGYXh5Z2phejl1\n\
  140. N2pKY1k3ZGJhd1pFeG1hYXFCRlRwL2h2ZG9rcHQ4a1ByRVk4OTJPRHJ1CmJORUox\n\
  141. N1FPSmVMTVZZZk5Kcjl4TWZCQ3JQai8zOGh2RUdrbWVRNmRVWElvbVFNaUJGOVRB\n\
  142. Z01CQUFFPQotLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tCmludHJvZHVjdGlv\n\
  143. bi1wb2ludCBhdjVtcWl0Y2Q3cjJkandsYmN0c2Jlc2R3eGt0ZWtvegppcC1hZGRy\n\
  144. ZXNzIDE0NC43Ni44LjczCm9uaW9uLXBvcnQgNDQzCm9uaW9uLWtleQotLS0tLUJF\n\
  145. R0lOIFJTQSBQVUJMSUMgS0VZLS0tLS0KTUlHSkFvR0JBTzVweVZzQmpZQmNmMXBE\n\
  146. dklHUlpmWXUzQ05nNldka0ZLMGlvdTBXTGZtejZRVDN0NWhzd3cyVwpjejlHMXhx\n\
  147. MmN0Nkd6VWkrNnVkTDlITTRVOUdHTi9BbW8wRG9GV1hKWHpBQkFXd2YyMVdsd1lW\n\
  148. eFJQMHRydi9WCkN6UDkzcHc5OG5vSmdGUGRUZ05iMjdKYmVUZENLVFBrTEtscXFt\n\
  149. b3NveUN2RitRa25vUS9BZ01CQUFFPQotLS0tLUVORCBSU0EgUFVCTElDIEtFWS0t\n\
  150. LS0tCnNlcnZpY2Uta2V5Ci0tLS0tQkVHSU4gUlNBIFBVQkxJQyBLRVktLS0tLQpN\n\
  151. SUdKQW9HQkFMVjNKSmtWN3lTNU9jc1lHMHNFYzFQOTVRclFRR3ZzbGJ6Wi9zRGxl\n\
  152. RlpKYXFSOUYvYjRUVERNClNGcFMxcU1GbldkZDgxVmRGMEdYRmN2WVpLamRJdHU2\n\
  153. SndBaTRJeEhxeXZtdTRKdUxrcXNaTEFLaXRLVkx4eGsKeERlMjlDNzRWMmJrOTRJ\n\
  154. MEgybTNKS2tzTHVwc3VxWWRVUmhOVXN0SElKZmgyZmNIalF0bEFnTUJBQUU9Ci0t\n\
  155. LS0tRU5EIFJTQSBQVUJMSUMgS0VZLS0tLS0KCg==\n\
  156. -----END MESSAGE-----\n\
  157. signature\n\
  158. -----BEGIN SIGNATURE-----\n\
  159. d4OuCE5OLAOnRB6cQN6WyMEmg/BHem144Vec+eYgeWoKwx3MxXFplUjFxgnMlmwN\n\
  160. PcftsZf2ztN0sbNCtPgDL3d0PqvxY3iHTQAI8EbaGq/IAJUZ8U4y963dD5+Bn6JQ\n\
  161. myE3ctmh0vy5+QxSiRjmQBkuEpCyks7LvWvHYrhnmcg=\n\
  162. -----END SIGNATURE-----";
  163. /* Helper global variable for hidden service descriptor event test.
  164. * It's used as a pointer to dynamically created message buffer in
  165. * send_control_event_string_replacement function, which mocks
  166. * send_control_event_string function.
  167. *
  168. * Always free it after use! */
  169. static char *received_msg = NULL;
  170. /** Mock function for send_control_event_string
  171. */
  172. static void
  173. queue_control_event_string_replacement(uint16_t event, char *msg)
  174. {
  175. (void) event;
  176. tor_free(received_msg);
  177. received_msg = msg;
  178. }
  179. /** Mock function for node_describe_longname_by_id, it returns either
  180. * STR_HSDIR_EXIST_LONGNAME or STR_HSDIR_NONE_EXIST_LONGNAME
  181. */
  182. static const char *
  183. node_describe_longname_by_id_replacement(const char *id_digest)
  184. {
  185. if (!strcmp(id_digest, HSDIR_EXIST_ID)) {
  186. return STR_HSDIR_EXIST_LONGNAME;
  187. } else {
  188. return STR_HSDIR_NONE_EXIST_LONGNAME;
  189. }
  190. }
  191. /** Test that we can parse a hardcoded v2 HS desc. */
  192. static void
  193. test_hs_parse_static_v2_desc(void *arg)
  194. {
  195. int ret;
  196. rend_encoded_v2_service_descriptor_t desc;
  197. (void) arg;
  198. /* Test an obviously not parseable string */
  199. desc.desc_str = tor_strdup("ceci n'est pas un HS descriptor");
  200. ret = rend_desc_v2_is_parsable(&desc);
  201. tor_free(desc.desc_str);
  202. tt_int_op(ret, OP_EQ, 0);
  203. /* Test an actual descriptor */
  204. desc.desc_str = tor_strdup(hs_desc_content);
  205. ret = rend_desc_v2_is_parsable(&desc);
  206. tor_free(desc.desc_str);
  207. tt_int_op(ret, OP_EQ, 1);
  208. done: ;
  209. }
  210. /** Make sure each hidden service descriptor async event generation
  211. *
  212. * function generates the message in expected format.
  213. */
  214. static void
  215. test_hs_desc_event(void *arg)
  216. {
  217. #define STR_HS_ADDR "ajhb7kljbiru65qo"
  218. #define STR_HS_CONTENT_DESC_ID "g5ojobzupf275beh5ra72uyhb3dkpxwg"
  219. #define STR_DESC_ID_BASE32 "hba3gmcgpfivzfhx5rtfqkfdhv65yrj3"
  220. int ret;
  221. rend_data_v2_t rend_query;
  222. const char *expected_msg;
  223. char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  224. (void) arg;
  225. MOCK(queue_control_event_string,
  226. queue_control_event_string_replacement);
  227. MOCK(node_describe_longname_by_id,
  228. node_describe_longname_by_id_replacement);
  229. /* setup rend_query struct */
  230. memset(&rend_query, 0, sizeof(rend_query));
  231. rend_query.base_.version = 2;
  232. strncpy(rend_query.onion_address, STR_HS_ADDR,
  233. REND_SERVICE_ID_LEN_BASE32+1);
  234. rend_query.auth_type = REND_NO_AUTH;
  235. rend_query.base_.hsdirs_fp = smartlist_new();
  236. smartlist_add(rend_query.base_.hsdirs_fp, tor_memdup(HSDIR_EXIST_ID,
  237. DIGEST_LEN));
  238. /* Compute descriptor ID for replica 0, should be STR_DESC_ID_BASE32. */
  239. ret = rend_compute_v2_desc_id(rend_query.descriptor_id[0],
  240. rend_query.onion_address,
  241. NULL, 0, 0);
  242. tt_int_op(ret, OP_EQ, 0);
  243. base32_encode(desc_id_base32, sizeof(desc_id_base32),
  244. rend_query.descriptor_id[0], DIGEST_LEN);
  245. /* Make sure rend_compute_v2_desc_id works properly. */
  246. tt_mem_op(desc_id_base32, OP_EQ, STR_DESC_ID_BASE32,
  247. sizeof(desc_id_base32));
  248. /* test request event */
  249. control_event_hs_descriptor_requested(rend_query.onion_address,
  250. rend_query.auth_type, HSDIR_EXIST_ID,
  251. STR_DESC_ID_BASE32, NULL);
  252. expected_msg = "650 HS_DESC REQUESTED "STR_HS_ADDR" NO_AUTH "\
  253. STR_HSDIR_EXIST_LONGNAME " " STR_DESC_ID_BASE32 "\r\n";
  254. tt_assert(received_msg);
  255. tt_str_op(received_msg,OP_EQ, expected_msg);
  256. tor_free(received_msg);
  257. /* test received event */
  258. rend_query.auth_type = REND_BASIC_AUTH;
  259. control_event_hsv2_descriptor_received(rend_query.onion_address,
  260. &rend_query.base_, HSDIR_EXIST_ID);
  261. expected_msg = "650 HS_DESC RECEIVED "STR_HS_ADDR" BASIC_AUTH "\
  262. STR_HSDIR_EXIST_LONGNAME " " STR_DESC_ID_BASE32"\r\n";
  263. tt_assert(received_msg);
  264. tt_str_op(received_msg,OP_EQ, expected_msg);
  265. tor_free(received_msg);
  266. /* test failed event */
  267. rend_query.auth_type = REND_STEALTH_AUTH;
  268. control_event_hsv2_descriptor_failed(&rend_query.base_,
  269. HSDIR_NONE_EXIST_ID,
  270. "QUERY_REJECTED");
  271. expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" STEALTH_AUTH "\
  272. STR_HSDIR_NONE_EXIST_LONGNAME" REASON=QUERY_REJECTED\r\n";
  273. tt_assert(received_msg);
  274. tt_str_op(received_msg,OP_EQ, expected_msg);
  275. tor_free(received_msg);
  276. /* test invalid auth type */
  277. rend_query.auth_type = 999;
  278. control_event_hsv2_descriptor_failed(&rend_query.base_,
  279. HSDIR_EXIST_ID,
  280. "QUERY_REJECTED");
  281. expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" UNKNOWN "\
  282. STR_HSDIR_EXIST_LONGNAME " " STR_DESC_ID_BASE32\
  283. " REASON=QUERY_REJECTED\r\n";
  284. tt_assert(received_msg);
  285. tt_str_op(received_msg,OP_EQ, expected_msg);
  286. tor_free(received_msg);
  287. /* test no HSDir fingerprint type */
  288. rend_query.auth_type = REND_NO_AUTH;
  289. control_event_hsv2_descriptor_failed(&rend_query.base_, NULL,
  290. "QUERY_NO_HSDIR");
  291. expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" NO_AUTH " \
  292. "UNKNOWN REASON=QUERY_NO_HSDIR\r\n";
  293. tt_assert(received_msg);
  294. tt_str_op(received_msg,OP_EQ, expected_msg);
  295. tor_free(received_msg);
  296. /* Test invalid content with no HSDir fingerprint. */
  297. char *exp_msg;
  298. control_event_hs_descriptor_content(rend_query.onion_address,
  299. STR_HS_CONTENT_DESC_ID, NULL, NULL);
  300. tor_asprintf(&exp_msg, "650+HS_DESC_CONTENT " STR_HS_ADDR " "\
  301. STR_HS_CONTENT_DESC_ID " UNKNOWN" \
  302. "\r\n\r\n.\r\n650 OK\r\n");
  303. tt_assert(received_msg);
  304. tt_str_op(received_msg, OP_EQ, exp_msg);
  305. tor_free(received_msg);
  306. tor_free(exp_msg);
  307. /* test valid content. */
  308. control_event_hs_descriptor_content(rend_query.onion_address,
  309. STR_HS_CONTENT_DESC_ID, HSDIR_EXIST_ID,
  310. hs_desc_content_control);
  311. tor_asprintf(&exp_msg, "650+HS_DESC_CONTENT " STR_HS_ADDR " "\
  312. STR_HS_CONTENT_DESC_ID " " STR_HSDIR_EXIST_LONGNAME\
  313. "\r\n%s\r\n.\r\n650 OK\r\n", hs_desc_content_control);
  314. tt_assert(received_msg);
  315. tt_str_op(received_msg, OP_EQ, exp_msg);
  316. tor_free(received_msg);
  317. tor_free(exp_msg);
  318. SMARTLIST_FOREACH(rend_query.base_.hsdirs_fp, char *, d, tor_free(d));
  319. smartlist_free(rend_query.base_.hsdirs_fp);
  320. done:
  321. UNMOCK(queue_control_event_string);
  322. UNMOCK(node_describe_longname_by_id);
  323. tor_free(received_msg);
  324. }
  325. /* Make sure rend_data_t is valid at creation, destruction and when
  326. * duplicated. */
  327. static void
  328. test_hs_rend_data(void *arg)
  329. {
  330. int rep;
  331. rend_data_t *client = NULL, *client_dup = NULL;
  332. /* Binary format of a descriptor ID. */
  333. char desc_id[DIGEST_LEN];
  334. char client_cookie[REND_DESC_COOKIE_LEN];
  335. time_t now = time(NULL);
  336. rend_data_t *service_dup = NULL;
  337. rend_data_t *service = NULL;
  338. (void)arg;
  339. base32_decode(desc_id, sizeof(desc_id), STR_DESC_ID_BASE32,
  340. REND_DESC_ID_V2_LEN_BASE32);
  341. memset(client_cookie, 'e', sizeof(client_cookie));
  342. client = rend_data_client_create(STR_HS_ADDR, desc_id, client_cookie,
  343. REND_NO_AUTH);
  344. tt_assert(client);
  345. rend_data_v2_t *client_v2 = TO_REND_DATA_V2(client);
  346. tt_int_op(client_v2->auth_type, OP_EQ, REND_NO_AUTH);
  347. tt_str_op(client_v2->onion_address, OP_EQ, STR_HS_ADDR);
  348. tt_mem_op(client_v2->desc_id_fetch, OP_EQ, desc_id, sizeof(desc_id));
  349. tt_mem_op(client_v2->descriptor_cookie, OP_EQ, client_cookie,
  350. sizeof(client_cookie));
  351. tt_assert(client->hsdirs_fp);
  352. tt_int_op(smartlist_len(client->hsdirs_fp), OP_EQ, 0);
  353. for (rep = 0; rep < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS; rep++) {
  354. int ret = rend_compute_v2_desc_id(desc_id, client_v2->onion_address,
  355. client_v2->descriptor_cookie, now, rep);
  356. /* That shouldn't never fail. */
  357. tt_int_op(ret, OP_EQ, 0);
  358. tt_mem_op(client_v2->descriptor_id[rep], OP_EQ, desc_id,
  359. sizeof(desc_id));
  360. }
  361. /* The rest should be zeroed because this is a client request. */
  362. tt_int_op(tor_digest_is_zero(client_v2->rend_pk_digest), OP_EQ, 1);
  363. tt_int_op(tor_digest_is_zero(client->rend_cookie), OP_EQ, 1);
  364. /* Test dup(). */
  365. client_dup = rend_data_dup(client);
  366. tt_assert(client_dup);
  367. rend_data_v2_t *client_dup_v2 = TO_REND_DATA_V2(client_dup);
  368. tt_int_op(client_dup_v2->auth_type, OP_EQ, client_v2->auth_type);
  369. tt_str_op(client_dup_v2->onion_address, OP_EQ, client_v2->onion_address);
  370. tt_mem_op(client_dup_v2->desc_id_fetch, OP_EQ, client_v2->desc_id_fetch,
  371. sizeof(client_dup_v2->desc_id_fetch));
  372. tt_mem_op(client_dup_v2->descriptor_cookie, OP_EQ,
  373. client_v2->descriptor_cookie,
  374. sizeof(client_dup_v2->descriptor_cookie));
  375. tt_assert(client_dup->hsdirs_fp);
  376. tt_int_op(smartlist_len(client_dup->hsdirs_fp), OP_EQ, 0);
  377. for (rep = 0; rep < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS; rep++) {
  378. tt_mem_op(client_dup_v2->descriptor_id[rep], OP_EQ,
  379. client_v2->descriptor_id[rep], DIGEST_LEN);
  380. }
  381. /* The rest should be zeroed because this is a client request. */
  382. tt_int_op(tor_digest_is_zero(client_dup_v2->rend_pk_digest), OP_EQ, 1);
  383. tt_int_op(tor_digest_is_zero(client_dup->rend_cookie), OP_EQ, 1);
  384. rend_data_free(client);
  385. client = NULL;
  386. rend_data_free(client_dup);
  387. client_dup = NULL;
  388. /* Reset state. */
  389. base32_decode(desc_id, sizeof(desc_id), STR_DESC_ID_BASE32,
  390. REND_DESC_ID_V2_LEN_BASE32);
  391. memset(client_cookie, 'e', sizeof(client_cookie));
  392. /* Try with different parameters here for which some content should be
  393. * zeroed out. */
  394. client = rend_data_client_create(NULL, desc_id, NULL, REND_BASIC_AUTH);
  395. tt_assert(client);
  396. client_v2 = TO_REND_DATA_V2(client);
  397. tt_int_op(client_v2->auth_type, OP_EQ, REND_BASIC_AUTH);
  398. tt_int_op(strlen(client_v2->onion_address), OP_EQ, 0);
  399. tt_mem_op(client_v2->desc_id_fetch, OP_EQ, desc_id, sizeof(desc_id));
  400. tt_int_op(tor_mem_is_zero(client_v2->descriptor_cookie,
  401. sizeof(client_v2->descriptor_cookie)), OP_EQ, 1);
  402. tt_assert(client->hsdirs_fp);
  403. tt_int_op(smartlist_len(client->hsdirs_fp), OP_EQ, 0);
  404. for (rep = 0; rep < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS; rep++) {
  405. tt_int_op(tor_digest_is_zero(client_v2->descriptor_id[rep]), OP_EQ, 1);
  406. }
  407. /* The rest should be zeroed because this is a client request. */
  408. tt_int_op(tor_digest_is_zero(client_v2->rend_pk_digest), OP_EQ, 1);
  409. tt_int_op(tor_digest_is_zero(client->rend_cookie), OP_EQ, 1);
  410. rend_data_free(client);
  411. client = NULL;
  412. /* Let's test the service object now. */
  413. char rend_pk_digest[DIGEST_LEN];
  414. uint8_t rend_cookie[DIGEST_LEN];
  415. memset(rend_pk_digest, 'f', sizeof(rend_pk_digest));
  416. memset(rend_cookie, 'g', sizeof(rend_cookie));
  417. service = rend_data_service_create(STR_HS_ADDR, rend_pk_digest,
  418. rend_cookie, REND_NO_AUTH);
  419. tt_assert(service);
  420. rend_data_v2_t *service_v2 = TO_REND_DATA_V2(service);
  421. tt_int_op(service_v2->auth_type, OP_EQ, REND_NO_AUTH);
  422. tt_str_op(service_v2->onion_address, OP_EQ, STR_HS_ADDR);
  423. tt_mem_op(service_v2->rend_pk_digest, OP_EQ, rend_pk_digest,
  424. sizeof(rend_pk_digest));
  425. tt_mem_op(service->rend_cookie, OP_EQ, rend_cookie, sizeof(rend_cookie));
  426. tt_assert(service->hsdirs_fp);
  427. tt_int_op(smartlist_len(service->hsdirs_fp), OP_EQ, 0);
  428. for (rep = 0; rep < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS; rep++) {
  429. tt_int_op(tor_digest_is_zero(service_v2->descriptor_id[rep]), OP_EQ, 1);
  430. }
  431. /* The rest should be zeroed because this is a service request. */
  432. tt_int_op(tor_digest_is_zero(service_v2->descriptor_cookie), OP_EQ, 1);
  433. tt_int_op(tor_digest_is_zero(service_v2->desc_id_fetch), OP_EQ, 1);
  434. /* Test dup(). */
  435. service_dup = rend_data_dup(service);
  436. rend_data_v2_t *service_dup_v2 = TO_REND_DATA_V2(service_dup);
  437. tt_assert(service_dup);
  438. tt_int_op(service_dup_v2->auth_type, OP_EQ, service_v2->auth_type);
  439. tt_str_op(service_dup_v2->onion_address, OP_EQ, service_v2->onion_address);
  440. tt_mem_op(service_dup_v2->rend_pk_digest, OP_EQ, service_v2->rend_pk_digest,
  441. sizeof(service_dup_v2->rend_pk_digest));
  442. tt_mem_op(service_dup->rend_cookie, OP_EQ, service->rend_cookie,
  443. sizeof(service_dup->rend_cookie));
  444. tt_assert(service_dup->hsdirs_fp);
  445. tt_int_op(smartlist_len(service_dup->hsdirs_fp), OP_EQ, 0);
  446. for (rep = 0; rep < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS; rep++) {
  447. tt_assert(tor_digest_is_zero(service_dup_v2->descriptor_id[rep]));
  448. }
  449. /* The rest should be zeroed because this is a service request. */
  450. tt_int_op(tor_digest_is_zero(service_dup_v2->descriptor_cookie), OP_EQ, 1);
  451. tt_int_op(tor_digest_is_zero(service_dup_v2->desc_id_fetch), OP_EQ, 1);
  452. done:
  453. rend_data_free(service);
  454. rend_data_free(service_dup);
  455. rend_data_free(client);
  456. rend_data_free(client_dup);
  457. }
  458. /* Test encoding and decoding service authorization cookies */
  459. static void
  460. test_hs_auth_cookies(void *arg)
  461. {
  462. #define TEST_COOKIE_RAW ((const uint8_t *) "abcdefghijklmnop")
  463. #define TEST_COOKIE_ENCODED "YWJjZGVmZ2hpamtsbW5vcA"
  464. #define TEST_COOKIE_ENCODED_STEALTH "YWJjZGVmZ2hpamtsbW5vcB"
  465. #define TEST_COOKIE_ENCODED_INVALID "YWJjZGVmZ2hpamtsbW5vcD"
  466. char *encoded_cookie = NULL;
  467. uint8_t raw_cookie[REND_DESC_COOKIE_LEN];
  468. rend_auth_type_t auth_type;
  469. char *err_msg = NULL;
  470. int re;
  471. (void)arg;
  472. /* Test that encoding gives the expected result */
  473. encoded_cookie = rend_auth_encode_cookie(TEST_COOKIE_RAW, REND_BASIC_AUTH);
  474. tt_str_op(encoded_cookie, OP_EQ, TEST_COOKIE_ENCODED);
  475. tor_free(encoded_cookie);
  476. encoded_cookie = rend_auth_encode_cookie(TEST_COOKIE_RAW, REND_STEALTH_AUTH);
  477. tt_str_op(encoded_cookie, OP_EQ, TEST_COOKIE_ENCODED_STEALTH);
  478. tor_free(encoded_cookie);
  479. /* Decoding should give the original value */
  480. re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED, raw_cookie, &auth_type,
  481. &err_msg);
  482. tt_assert(!re);
  483. tt_ptr_op(err_msg, OP_EQ, NULL);
  484. tt_mem_op(raw_cookie, OP_EQ, TEST_COOKIE_RAW, REND_DESC_COOKIE_LEN);
  485. tt_int_op(auth_type, OP_EQ, REND_BASIC_AUTH);
  486. memset(raw_cookie, 0, sizeof(raw_cookie));
  487. re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED_STEALTH, raw_cookie,
  488. &auth_type, &err_msg);
  489. tt_assert(!re);
  490. tt_ptr_op(err_msg, OP_EQ, NULL);
  491. tt_mem_op(raw_cookie, OP_EQ, TEST_COOKIE_RAW, REND_DESC_COOKIE_LEN);
  492. tt_int_op(auth_type, OP_EQ, REND_STEALTH_AUTH);
  493. memset(raw_cookie, 0, sizeof(raw_cookie));
  494. /* Decoding with padding characters should also work */
  495. re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED "==", raw_cookie, NULL,
  496. &err_msg);
  497. tt_assert(!re);
  498. tt_ptr_op(err_msg, OP_EQ, NULL);
  499. tt_mem_op(raw_cookie, OP_EQ, TEST_COOKIE_RAW, REND_DESC_COOKIE_LEN);
  500. /* Decoding with an unknown type should fail */
  501. re = rend_auth_decode_cookie(TEST_COOKIE_ENCODED_INVALID, raw_cookie,
  502. &auth_type, &err_msg);
  503. tt_int_op(re, OP_LT, 0);
  504. tt_assert(err_msg);
  505. tor_free(err_msg);
  506. done:
  507. tor_free(encoded_cookie);
  508. tor_free(err_msg);
  509. return;
  510. }
  511. static int mock_get_options_calls = 0;
  512. static or_options_t *mock_options = NULL;
  513. static void
  514. reset_options(or_options_t *options, int *get_options_calls)
  515. {
  516. memset(options, 0, sizeof(or_options_t));
  517. options->TestingTorNetwork = 1;
  518. *get_options_calls = 0;
  519. }
  520. static const or_options_t *
  521. mock_get_options(void)
  522. {
  523. ++mock_get_options_calls;
  524. tor_assert(mock_options);
  525. return mock_options;
  526. }
  527. /* arg can't be 0 (the test fails) or 2 (the test is skipped) */
  528. #define CREATE_HS_DIR_NONE ((intptr_t)0x04)
  529. #define CREATE_HS_DIR1 ((intptr_t)0x08)
  530. #define CREATE_HS_DIR2 ((intptr_t)0x10)
  531. /* Test that single onion poisoning works. */
  532. static void
  533. test_single_onion_poisoning(void *arg)
  534. {
  535. or_options_t opt;
  536. mock_options = &opt;
  537. reset_options(mock_options, &mock_get_options_calls);
  538. MOCK(get_options, mock_get_options);
  539. int ret = -1;
  540. intptr_t create_dir_mask = (intptr_t)arg;
  541. /* Get directories with a random suffix so we can repeat the tests */
  542. mock_options->DataDirectory = tor_strdup(get_fname_rnd("test_data_dir"));
  543. rend_service_t *service_1 = tor_malloc_zero(sizeof(rend_service_t));
  544. char *dir1 = tor_strdup(get_fname_rnd("test_hs_dir1"));
  545. rend_service_t *service_2 = tor_malloc_zero(sizeof(rend_service_t));
  546. char *dir2 = tor_strdup(get_fname_rnd("test_hs_dir2"));
  547. smartlist_t *services = smartlist_new();
  548. char *poison_path = NULL;
  549. char *err_msg = NULL;
  550. mock_options->HiddenServiceSingleHopMode = 1;
  551. mock_options->HiddenServiceNonAnonymousMode = 1;
  552. /* Create the data directory, and, if the correct bit in arg is set,
  553. * create a directory for that service.
  554. * The data directory is required for the lockfile, which is used when
  555. * loading keys. */
  556. ret = check_private_dir(mock_options->DataDirectory, CPD_CREATE, NULL);
  557. tt_int_op(ret, OP_EQ, 0);
  558. if (create_dir_mask & CREATE_HS_DIR1) {
  559. ret = check_private_dir(dir1, CPD_CREATE, NULL);
  560. tt_int_op(ret, OP_EQ, 0);
  561. }
  562. if (create_dir_mask & CREATE_HS_DIR2) {
  563. ret = check_private_dir(dir2, CPD_CREATE, NULL);
  564. tt_int_op(ret, OP_EQ, 0);
  565. }
  566. service_1->directory = dir1;
  567. service_2->directory = dir2;
  568. /* The services own the directory pointers now */
  569. dir1 = dir2 = NULL;
  570. /* Add port to service 1 */
  571. service_1->ports = smartlist_new();
  572. service_2->ports = smartlist_new();
  573. rend_service_port_config_t *port1 = rend_service_parse_port_config("80", " ",
  574. &err_msg);
  575. tt_assert(port1);
  576. tt_ptr_op(err_msg, OP_EQ, NULL);
  577. smartlist_add(service_1->ports, port1);
  578. rend_service_port_config_t *port2 = rend_service_parse_port_config("90", " ",
  579. &err_msg);
  580. /* Add port to service 2 */
  581. tt_assert(port2);
  582. tt_ptr_op(err_msg, OP_EQ, NULL);
  583. smartlist_add(service_2->ports, port2);
  584. /* No services, a service to verify, no problem! */
  585. mock_options->HiddenServiceSingleHopMode = 0;
  586. mock_options->HiddenServiceNonAnonymousMode = 0;
  587. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  588. tt_int_op(ret, OP_EQ, 0);
  589. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  590. tt_int_op(ret, OP_EQ, 0);
  591. /* Either way, no problem. */
  592. mock_options->HiddenServiceSingleHopMode = 1;
  593. mock_options->HiddenServiceNonAnonymousMode = 1;
  594. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  595. tt_int_op(ret, OP_EQ, 0);
  596. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  597. tt_int_op(ret, OP_EQ, 0);
  598. /* Add the first service */
  599. ret = hs_check_service_private_dir(mock_options->User, service_1->directory,
  600. service_1->dir_group_readable, 1);
  601. tt_int_op(ret, OP_EQ, 0);
  602. smartlist_add(services, service_1);
  603. /* But don't add the second service yet. */
  604. /* Service directories, but no previous keys, no problem! */
  605. mock_options->HiddenServiceSingleHopMode = 0;
  606. mock_options->HiddenServiceNonAnonymousMode = 0;
  607. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  608. tt_int_op(ret, OP_EQ, 0);
  609. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  610. tt_int_op(ret, OP_EQ, 0);
  611. /* Either way, no problem. */
  612. mock_options->HiddenServiceSingleHopMode = 1;
  613. mock_options->HiddenServiceNonAnonymousMode = 1;
  614. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  615. tt_int_op(ret, OP_EQ, 0);
  616. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  617. tt_int_op(ret, OP_EQ, 0);
  618. /* Poison! Poison! Poison!
  619. * This can only be done in HiddenServiceSingleHopMode. */
  620. mock_options->HiddenServiceSingleHopMode = 1;
  621. mock_options->HiddenServiceNonAnonymousMode = 1;
  622. ret = rend_service_poison_new_single_onion_dir(service_1, mock_options);
  623. tt_int_op(ret, OP_EQ, 0);
  624. /* Poisoning twice is a no-op. */
  625. ret = rend_service_poison_new_single_onion_dir(service_1, mock_options);
  626. tt_int_op(ret, OP_EQ, 0);
  627. /* Poisoned service directories, but no previous keys, no problem! */
  628. mock_options->HiddenServiceSingleHopMode = 0;
  629. mock_options->HiddenServiceNonAnonymousMode = 0;
  630. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  631. tt_int_op(ret, OP_EQ, 0);
  632. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  633. tt_int_op(ret, OP_EQ, 0);
  634. /* Either way, no problem. */
  635. mock_options->HiddenServiceSingleHopMode = 1;
  636. mock_options->HiddenServiceNonAnonymousMode = 1;
  637. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  638. tt_int_op(ret, OP_EQ, 0);
  639. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  640. tt_int_op(ret, OP_EQ, 0);
  641. /* Now add some keys, and we'll have a problem. */
  642. ret = rend_service_load_all_keys(services);
  643. tt_int_op(ret, OP_EQ, 0);
  644. /* Poisoned service directories with previous keys are not allowed. */
  645. mock_options->HiddenServiceSingleHopMode = 0;
  646. mock_options->HiddenServiceNonAnonymousMode = 0;
  647. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  648. tt_int_op(ret, OP_LT, 0);
  649. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  650. tt_int_op(ret, OP_EQ, 0);
  651. /* But they are allowed if we're in non-anonymous mode. */
  652. mock_options->HiddenServiceSingleHopMode = 1;
  653. mock_options->HiddenServiceNonAnonymousMode = 1;
  654. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  655. tt_int_op(ret, OP_EQ, 0);
  656. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  657. tt_int_op(ret, OP_EQ, 0);
  658. /* Re-poisoning directories with existing keys is a no-op, because
  659. * directories with existing keys are ignored. */
  660. mock_options->HiddenServiceSingleHopMode = 1;
  661. mock_options->HiddenServiceNonAnonymousMode = 1;
  662. ret = rend_service_poison_new_single_onion_dir(service_1, mock_options);
  663. tt_int_op(ret, OP_EQ, 0);
  664. /* And it keeps the poison. */
  665. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  666. tt_int_op(ret, OP_EQ, 0);
  667. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  668. tt_int_op(ret, OP_EQ, 0);
  669. /* Now add the second service: it has no key and no poison file */
  670. ret = hs_check_service_private_dir(mock_options->User, service_2->directory,
  671. service_2->dir_group_readable, 1);
  672. tt_int_op(ret, OP_EQ, 0);
  673. smartlist_add(services, service_2);
  674. /* A new service, and an existing poisoned service. Not ok. */
  675. mock_options->HiddenServiceSingleHopMode = 0;
  676. mock_options->HiddenServiceNonAnonymousMode = 0;
  677. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  678. tt_int_op(ret, OP_LT, 0);
  679. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  680. tt_int_op(ret, OP_EQ, 0);
  681. /* But ok to add in non-anonymous mode. */
  682. mock_options->HiddenServiceSingleHopMode = 1;
  683. mock_options->HiddenServiceNonAnonymousMode = 1;
  684. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  685. tt_int_op(ret, OP_EQ, 0);
  686. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  687. tt_int_op(ret, OP_EQ, 0);
  688. /* Now remove the poisoning from the first service, and we have the opposite
  689. * problem. */
  690. poison_path = rend_service_sos_poison_path(service_1);
  691. tt_assert(poison_path);
  692. ret = unlink(poison_path);
  693. tt_int_op(ret, OP_EQ, 0);
  694. /* Unpoisoned service directories with previous keys are ok, as are empty
  695. * directories. */
  696. mock_options->HiddenServiceSingleHopMode = 0;
  697. mock_options->HiddenServiceNonAnonymousMode = 0;
  698. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  699. tt_int_op(ret, OP_EQ, 0);
  700. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  701. tt_int_op(ret, OP_EQ, 0);
  702. /* But the existing unpoisoned key is not ok in non-anonymous mode, even if
  703. * there is an empty service. */
  704. mock_options->HiddenServiceSingleHopMode = 1;
  705. mock_options->HiddenServiceNonAnonymousMode = 1;
  706. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  707. tt_int_op(ret, OP_LT, 0);
  708. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  709. tt_int_op(ret, OP_EQ, 0);
  710. /* Poisoning directories with existing keys is a no-op, because directories
  711. * with existing keys are ignored. But the new directory should poison. */
  712. mock_options->HiddenServiceSingleHopMode = 1;
  713. mock_options->HiddenServiceNonAnonymousMode = 1;
  714. ret = rend_service_poison_new_single_onion_dir(service_1, mock_options);
  715. tt_int_op(ret, OP_EQ, 0);
  716. ret = rend_service_poison_new_single_onion_dir(service_2, mock_options);
  717. tt_int_op(ret, OP_EQ, 0);
  718. /* And the old directory remains unpoisoned. */
  719. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  720. tt_int_op(ret, OP_LT, 0);
  721. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  722. tt_int_op(ret, OP_EQ, 0);
  723. /* And the new directory should be ignored, because it has no key. */
  724. mock_options->HiddenServiceSingleHopMode = 0;
  725. mock_options->HiddenServiceNonAnonymousMode = 0;
  726. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  727. tt_int_op(ret, OP_EQ, 0);
  728. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  729. tt_int_op(ret, OP_EQ, 0);
  730. /* Re-poisoning directories without existing keys is a no-op. */
  731. mock_options->HiddenServiceSingleHopMode = 1;
  732. mock_options->HiddenServiceNonAnonymousMode = 1;
  733. ret = rend_service_poison_new_single_onion_dir(service_1, mock_options);
  734. tt_int_op(ret, OP_EQ, 0);
  735. ret = rend_service_poison_new_single_onion_dir(service_2, mock_options);
  736. tt_int_op(ret, OP_EQ, 0);
  737. /* And the old directory remains unpoisoned. */
  738. ret = rend_service_verify_single_onion_poison(service_1, mock_options);
  739. tt_int_op(ret, OP_LT, 0);
  740. ret = rend_service_verify_single_onion_poison(service_2, mock_options);
  741. tt_int_op(ret, OP_EQ, 0);
  742. done:
  743. /* The test harness deletes the directories at exit */
  744. tor_free(poison_path);
  745. tor_free(dir1);
  746. tor_free(dir2);
  747. smartlist_free(services);
  748. rend_service_free(service_1);
  749. rend_service_free(service_2);
  750. UNMOCK(get_options);
  751. tor_free(mock_options->DataDirectory);
  752. tor_free(err_msg);
  753. }
  754. static rend_service_t *
  755. helper_create_rend_service(const char *path)
  756. {
  757. rend_service_t *s = tor_malloc_zero(sizeof(rend_service_t));
  758. s->ports = smartlist_new();
  759. s->intro_nodes = smartlist_new();
  760. s->expiring_nodes = smartlist_new();
  761. if (path) {
  762. s->directory = tor_strdup(path);
  763. }
  764. return s;
  765. }
  766. static void
  767. test_prune_services_on_reload(void *arg)
  768. {
  769. smartlist_t *new = smartlist_new(), *old = smartlist_new();
  770. /* Non ephemeral service. */
  771. rend_service_t *s1 = helper_create_rend_service("SomePath");
  772. /* Create a non ephemeral service with the _same_ path as so we can test the
  773. * transfer of introduction point between the same services on reload. */
  774. rend_service_t *s2 = helper_create_rend_service(s1->directory);
  775. /* Ephemeral service (directory is NULL). */
  776. rend_service_t *e1 = helper_create_rend_service(NULL);
  777. rend_service_t *e2 = helper_create_rend_service(NULL);
  778. (void) arg;
  779. {
  780. /* Add both services to the old list. */
  781. smartlist_add(old, s1);
  782. smartlist_add(old, e1);
  783. /* Only put the non ephemeral in the new list. */
  784. smartlist_add(new, s1);
  785. set_rend_service_list(old);
  786. set_rend_rend_service_staging_list(new);
  787. rend_service_prune_list_impl_();
  788. /* We expect that the ephemeral one is in the new list but removed from
  789. * the old one. */
  790. tt_int_op(smartlist_len(old), OP_EQ, 1);
  791. tt_assert(smartlist_get(old, 0) == s1);
  792. tt_int_op(smartlist_len(new), OP_EQ, 2);
  793. tt_assert(smartlist_get(new, 0) == s1);
  794. tt_assert(smartlist_get(new, 1) == e1);
  795. /* Cleanup for next test. */
  796. smartlist_clear(new);
  797. smartlist_clear(old);
  798. }
  799. {
  800. /* This test will make sure that only the ephemeral service is kept if the
  801. * new list is empty. The old list should contain only the non ephemeral
  802. * one. */
  803. smartlist_add(old, s1);
  804. smartlist_add(old, e1);
  805. set_rend_service_list(old);
  806. set_rend_rend_service_staging_list(new);
  807. rend_service_prune_list_impl_();
  808. tt_int_op(smartlist_len(old), OP_EQ, 1);
  809. tt_assert(smartlist_get(old, 0) == s1);
  810. tt_int_op(smartlist_len(new), OP_EQ, 1);
  811. tt_assert(smartlist_get(new, 0) == e1);
  812. /* Cleanup for next test. */
  813. smartlist_clear(new);
  814. smartlist_clear(old);
  815. }
  816. {
  817. /* This test makes sure that the new list stays the same even from the old
  818. * list being completely different. */
  819. smartlist_add(new, s1);
  820. smartlist_add(new, e1);
  821. set_rend_service_list(old);
  822. set_rend_rend_service_staging_list(new);
  823. rend_service_prune_list_impl_();
  824. tt_int_op(smartlist_len(old), OP_EQ, 0);
  825. tt_int_op(smartlist_len(new), OP_EQ, 2);
  826. tt_assert(smartlist_get(new, 0) == s1);
  827. tt_assert(smartlist_get(new, 1) == e1);
  828. /* Cleanup for next test. */
  829. smartlist_clear(new);
  830. }
  831. {
  832. rend_intro_point_t ip1;
  833. /* This IP should be found in the s2 service after pruning. */
  834. smartlist_add(s1->intro_nodes, &ip1);
  835. /* Setup our list. */
  836. smartlist_add(old, s1);
  837. smartlist_add(new, s2);
  838. set_rend_service_list(old);
  839. set_rend_rend_service_staging_list(new);
  840. rend_service_prune_list_impl_();
  841. tt_int_op(smartlist_len(old), OP_EQ, 1);
  842. /* Intro nodes have been moved to the s2 in theory so it must be empty. */
  843. tt_int_op(smartlist_len(s1->intro_nodes), OP_EQ, 0);
  844. tt_int_op(smartlist_len(new), OP_EQ, 1);
  845. rend_service_t *elem = smartlist_get(new, 0);
  846. tt_assert(elem);
  847. tt_assert(elem == s2);
  848. tt_int_op(smartlist_len(elem->intro_nodes), OP_EQ, 1);
  849. tt_assert(smartlist_get(elem->intro_nodes, 0) == &ip1);
  850. smartlist_clear(s1->intro_nodes);
  851. smartlist_clear(s2->intro_nodes);
  852. /* Cleanup for next test. */
  853. smartlist_clear(new);
  854. smartlist_clear(old);
  855. }
  856. {
  857. /* Test two ephemeral services. */
  858. smartlist_add(old, e1);
  859. smartlist_add(old, e2);
  860. set_rend_service_list(old);
  861. set_rend_rend_service_staging_list(new);
  862. rend_service_prune_list_impl_();
  863. /* Check if they've all been transferred. */
  864. tt_int_op(smartlist_len(old), OP_EQ, 0);
  865. tt_int_op(smartlist_len(new), OP_EQ, 2);
  866. }
  867. done:
  868. rend_service_free(s1);
  869. rend_service_free(s2);
  870. rend_service_free(e1);
  871. rend_service_free(e2);
  872. smartlist_free(new);
  873. smartlist_free(old);
  874. }
  875. struct testcase_t hs_tests[] = {
  876. { "hs_rend_data", test_hs_rend_data, TT_FORK,
  877. NULL, NULL },
  878. { "hs_parse_static_v2_desc", test_hs_parse_static_v2_desc, TT_FORK,
  879. NULL, NULL },
  880. { "hs_desc_event", test_hs_desc_event, TT_FORK,
  881. NULL, NULL },
  882. { "hs_auth_cookies", test_hs_auth_cookies, TT_FORK,
  883. NULL, NULL },
  884. { "single_onion_poisoning_create_dir_none", test_single_onion_poisoning,
  885. TT_FORK, &passthrough_setup, (void*)(CREATE_HS_DIR_NONE) },
  886. { "single_onion_poisoning_create_dir1", test_single_onion_poisoning,
  887. TT_FORK, &passthrough_setup, (void*)(CREATE_HS_DIR1) },
  888. { "single_onion_poisoning_create_dir2", test_single_onion_poisoning,
  889. TT_FORK, &passthrough_setup, (void*)(CREATE_HS_DIR2) },
  890. { "single_onion_poisoning_create_dir_both", test_single_onion_poisoning,
  891. TT_FORK, &passthrough_setup, (void*)(CREATE_HS_DIR1 | CREATE_HS_DIR2) },
  892. { "prune_services_on_reload", test_prune_services_on_reload, TT_FORK,
  893. NULL, NULL },
  894. END_OF_TESTCASES
  895. };