LCOV - code coverage report
Current view: top level - src - torcontrol.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 41.4 % 379 157
Test Date: 2025-04-16 05:11:06 Functions: 60.7 % 28 17
Branches: 20.6 % 650 134

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2015-2022 The Bitcoin Core developers
       2                 :             : // Copyright (c) 2017 The Zcash developers
       3                 :             : // Distributed under the MIT software license, see the accompanying
       4                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :             : 
       6                 :             : #include <torcontrol.h>
       7                 :             : 
       8                 :             : #include <chainparams.h>
       9                 :             : #include <chainparamsbase.h>
      10                 :             : #include <common/args.h>
      11                 :             : #include <compat/compat.h>
      12                 :             : #include <crypto/hmac_sha256.h>
      13                 :             : #include <logging.h>
      14                 :             : #include <net.h>
      15                 :             : #include <netaddress.h>
      16                 :             : #include <netbase.h>
      17                 :             : #include <random.h>
      18                 :             : #include <tinyformat.h>
      19                 :             : #include <util/check.h>
      20                 :             : #include <util/fs.h>
      21                 :             : #include <util/readwritefile.h>
      22                 :             : #include <util/strencodings.h>
      23                 :             : #include <util/string.h>
      24                 :             : #include <util/thread.h>
      25                 :             : #include <util/time.h>
      26                 :             : 
      27                 :             : #include <algorithm>
      28                 :             : #include <cassert>
      29                 :             : #include <cstdint>
      30                 :             : #include <cstdlib>
      31                 :             : #include <deque>
      32                 :             : #include <functional>
      33                 :             : #include <map>
      34                 :             : #include <optional>
      35                 :             : #include <set>
      36                 :             : #include <thread>
      37                 :             : #include <utility>
      38                 :             : #include <vector>
      39                 :             : 
      40                 :             : #include <event2/buffer.h>
      41                 :             : #include <event2/bufferevent.h>
      42                 :             : #include <event2/event.h>
      43                 :             : #include <event2/thread.h>
      44                 :             : #include <event2/util.h>
      45                 :             : 
      46                 :             : using util::ReplaceAll;
      47                 :             : using util::SplitString;
      48                 :             : using util::ToString;
      49                 :             : 
      50                 :             : /** Default control ip and port */
      51                 :             : const std::string DEFAULT_TOR_CONTROL = "127.0.0.1:" + ToString(DEFAULT_TOR_CONTROL_PORT);
      52                 :             : /** Tor cookie size (from control-spec.txt) */
      53                 :             : static const int TOR_COOKIE_SIZE = 32;
      54                 :             : /** Size of client/server nonce for SAFECOOKIE */
      55                 :             : static const int TOR_NONCE_SIZE = 32;
      56                 :             : /** Tor control reply code. Ref: https://spec.torproject.org/control-spec/replies.html */
      57                 :             : static const int TOR_REPLY_OK = 250;
      58                 :             : static const int TOR_REPLY_UNRECOGNIZED = 510;
      59                 :             : /** For computing serverHash in SAFECOOKIE */
      60                 :             : static const std::string TOR_SAFE_SERVERKEY = "Tor safe cookie authentication server-to-controller hash";
      61                 :             : /** For computing clientHash in SAFECOOKIE */
      62                 :             : static const std::string TOR_SAFE_CLIENTKEY = "Tor safe cookie authentication controller-to-server hash";
      63                 :             : /** Exponential backoff configuration - initial timeout in seconds */
      64                 :             : static const float RECONNECT_TIMEOUT_START = 1.0;
      65                 :             : /** Exponential backoff configuration - growth factor */
      66                 :             : static const float RECONNECT_TIMEOUT_EXP = 1.5;
      67                 :             : /** Maximum reconnect timeout in seconds to prevent excessive delays */
      68                 :             : static const float RECONNECT_TIMEOUT_MAX = 600.0;
      69                 :             : /** Maximum length for lines received on TorControlConnection.
      70                 :             :  * tor-control-spec.txt mentions that there is explicitly no limit defined to line length,
      71                 :             :  * this is belt-and-suspenders sanity limit to prevent memory exhaustion.
      72                 :             :  */
      73                 :             : static const int MAX_LINE_LENGTH = 100000;
      74                 :             : static const uint16_t DEFAULT_TOR_SOCKS_PORT = 9050;
      75                 :             : 
      76                 :             : /****** Low-level TorControlConnection ********/
      77                 :             : 
      78                 :           1 : TorControlConnection::TorControlConnection(struct event_base* _base)
      79         [ +  - ]:           1 :     : base(_base)
      80                 :             : {
      81                 :           1 : }
      82                 :             : 
      83                 :           1 : TorControlConnection::~TorControlConnection()
      84                 :             : {
      85         [ -  + ]:           1 :     if (b_conn)
      86                 :           0 :         bufferevent_free(b_conn);
      87                 :           1 : }
      88                 :             : 
      89                 :           0 : void TorControlConnection::readcb(struct bufferevent *bev, void *ctx)
      90                 :             : {
      91                 :           0 :     TorControlConnection *self = static_cast<TorControlConnection*>(ctx);
      92                 :           0 :     struct evbuffer *input = bufferevent_get_input(bev);
      93                 :           0 :     size_t n_read_out = 0;
      94                 :           0 :     char *line;
      95         [ #  # ]:           0 :     assert(input);
      96                 :             :     //  If there is not a whole line to read, evbuffer_readln returns nullptr
      97         [ #  # ]:           0 :     while((line = evbuffer_readln(input, &n_read_out, EVBUFFER_EOL_CRLF)) != nullptr)
      98                 :             :     {
      99                 :           0 :         std::string s(line, n_read_out);
     100                 :           0 :         free(line);
     101         [ #  # ]:           0 :         if (s.size() < 4) // Short line
     102                 :           0 :             continue;
     103                 :             :         // <status>(-|+| )<data><CRLF>
     104   [ #  #  #  # ]:           0 :         self->message.code = ToIntegral<int>(s.substr(0, 3)).value_or(0);
     105         [ #  # ]:           0 :         self->message.lines.push_back(s.substr(4));
     106         [ #  # ]:           0 :         char ch = s[3]; // '-','+' or ' '
     107         [ #  # ]:           0 :         if (ch == ' ') {
     108                 :             :             // Final line, dispatch reply and clean up
     109         [ #  # ]:           0 :             if (self->message.code >= 600) {
     110                 :             :                 // (currently unused)
     111                 :             :                 // Dispatch async notifications to async handler
     112                 :             :                 // Synchronous and asynchronous messages are never interleaved
     113                 :             :             } else {
     114         [ #  # ]:           0 :                 if (!self->reply_handlers.empty()) {
     115                 :             :                     // Invoke reply handler with message
     116         [ #  # ]:           0 :                     self->reply_handlers.front()(*self, self->message);
     117                 :           0 :                     self->reply_handlers.pop_front();
     118                 :             :                 } else {
     119   [ #  #  #  #  :           0 :                     LogDebug(BCLog::TOR, "Received unexpected sync reply %i\n", self->message.code);
                   #  # ]
     120                 :             :                 }
     121                 :             :             }
     122                 :           0 :             self->message.Clear();
     123                 :             :         }
     124                 :           0 :     }
     125                 :             :     //  Check for size of buffer - protect against memory exhaustion with very long lines
     126                 :             :     //  Do this after evbuffer_readln to make sure all full lines have been
     127                 :             :     //  removed from the buffer. Everything left is an incomplete line.
     128         [ #  # ]:           0 :     if (evbuffer_get_length(input) > MAX_LINE_LENGTH) {
     129                 :           0 :         LogPrintf("tor: Disconnecting because MAX_LINE_LENGTH exceeded\n");
     130                 :           0 :         self->Disconnect();
     131                 :             :     }
     132                 :           0 : }
     133                 :             : 
     134                 :           1 : void TorControlConnection::eventcb(struct bufferevent *bev, short what, void *ctx)
     135                 :             : {
     136                 :           1 :     TorControlConnection *self = static_cast<TorControlConnection*>(ctx);
     137         [ -  + ]:           1 :     if (what & BEV_EVENT_CONNECTED) {
     138         [ #  # ]:           0 :         LogDebug(BCLog::TOR, "Successfully connected!\n");
     139                 :           0 :         self->connected(*self);
     140         [ +  - ]:           1 :     } else if (what & (BEV_EVENT_EOF|BEV_EVENT_ERROR)) {
     141         [ +  - ]:           1 :         if (what & BEV_EVENT_ERROR) {
     142         [ +  - ]:           1 :             LogDebug(BCLog::TOR, "Error connecting to Tor control socket\n");
     143                 :             :         } else {
     144         [ #  # ]:           0 :             LogDebug(BCLog::TOR, "End of stream\n");
     145                 :             :         }
     146                 :           1 :         self->Disconnect();
     147                 :           1 :         self->disconnected(*self);
     148                 :             :     }
     149                 :           1 : }
     150                 :             : 
     151                 :           1 : bool TorControlConnection::Connect(const std::string& tor_control_center, const ConnectionCB& _connected, const ConnectionCB& _disconnected)
     152                 :             : {
     153         [ -  + ]:           1 :     if (b_conn) {
     154                 :           0 :         Disconnect();
     155                 :             :     }
     156                 :             : 
     157         [ +  - ]:           1 :     const std::optional<CService> control_service{Lookup(tor_control_center, DEFAULT_TOR_CONTROL_PORT, fNameLookup)};
     158         [ -  + ]:           1 :     if (!control_service.has_value()) {
     159         [ #  # ]:           0 :         LogPrintf("tor: Failed to look up control center %s\n", tor_control_center);
     160                 :             :         return false;
     161                 :             :     }
     162                 :             : 
     163                 :           1 :     struct sockaddr_storage control_address;
     164                 :           1 :     socklen_t control_address_len = sizeof(control_address);
     165   [ +  -  -  + ]:           1 :     if (!control_service.value().GetSockAddr(reinterpret_cast<struct sockaddr*>(&control_address), &control_address_len)) {
     166         [ #  # ]:           0 :         LogPrintf("tor: Error parsing socket address %s\n", tor_control_center);
     167                 :             :         return false;
     168                 :             :     }
     169                 :             : 
     170                 :             :     // Create a new socket, set up callbacks and enable notification bits
     171         [ +  - ]:           1 :     b_conn = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
     172         [ +  - ]:           1 :     if (!b_conn) {
     173                 :             :         return false;
     174                 :             :     }
     175         [ +  - ]:           1 :     bufferevent_setcb(b_conn, TorControlConnection::readcb, nullptr, TorControlConnection::eventcb, this);
     176         [ +  - ]:           1 :     bufferevent_enable(b_conn, EV_READ|EV_WRITE);
     177         [ +  - ]:           1 :     this->connected = _connected;
     178         [ +  - ]:           1 :     this->disconnected = _disconnected;
     179                 :             : 
     180                 :             :     // Finally, connect to tor_control_center
     181   [ +  -  -  + ]:           1 :     if (bufferevent_socket_connect(b_conn, reinterpret_cast<struct sockaddr*>(&control_address), control_address_len) < 0) {
     182         [ #  # ]:           0 :         LogPrintf("tor: Error connecting to address %s\n", tor_control_center);
     183                 :             :         return false;
     184                 :             :     }
     185                 :             :     return true;
     186                 :           1 : }
     187                 :             : 
     188                 :           1 : void TorControlConnection::Disconnect()
     189                 :             : {
     190         [ +  - ]:           1 :     if (b_conn)
     191                 :           1 :         bufferevent_free(b_conn);
     192                 :           1 :     b_conn = nullptr;
     193                 :           1 : }
     194                 :             : 
     195                 :           0 : bool TorControlConnection::Command(const std::string &cmd, const ReplyHandlerCB& reply_handler)
     196                 :             : {
     197         [ #  # ]:           0 :     if (!b_conn)
     198                 :             :         return false;
     199                 :           0 :     struct evbuffer *buf = bufferevent_get_output(b_conn);
     200         [ #  # ]:           0 :     if (!buf)
     201                 :             :         return false;
     202                 :           0 :     evbuffer_add(buf, cmd.data(), cmd.size());
     203                 :           0 :     evbuffer_add(buf, "\r\n", 2);
     204                 :           0 :     reply_handlers.push_back(reply_handler);
     205                 :           0 :     return true;
     206                 :             : }
     207                 :             : 
     208                 :             : /****** General parsing utilities ********/
     209                 :             : 
     210                 :             : /* Split reply line in the form 'AUTH METHODS=...' into a type
     211                 :             :  * 'AUTH' and arguments 'METHODS=...'.
     212                 :             :  * Grammar is implicitly defined in https://spec.torproject.org/control-spec by
     213                 :             :  * the server reply formats for PROTOCOLINFO (S3.21) and AUTHCHALLENGE (S3.24).
     214                 :             :  */
     215                 :          10 : std::pair<std::string,std::string> SplitTorReplyLine(const std::string &s)
     216                 :             : {
     217                 :          10 :     size_t ptr=0;
     218                 :          10 :     std::string type;
     219   [ +  +  +  + ]:          82 :     while (ptr < s.size() && s[ptr] != ' ') {
     220         [ +  - ]:          72 :         type.push_back(s[ptr]);
     221                 :          72 :         ++ptr;
     222                 :             :     }
     223         [ +  + ]:          10 :     if (ptr < s.size())
     224                 :           9 :         ++ptr; // skip ' '
     225         [ +  - ]:          20 :     return make_pair(type, s.substr(ptr));
     226                 :          10 : }
     227                 :             : 
     228                 :             : /** Parse reply arguments in the form 'METHODS=COOKIE,SAFECOOKIE COOKIEFILE=".../control_auth_cookie"'.
     229                 :             :  * Returns a map of keys to values, or an empty map if there was an error.
     230                 :             :  * Grammar is implicitly defined in https://spec.torproject.org/control-spec by
     231                 :             :  * the server reply formats for PROTOCOLINFO (S3.21), AUTHCHALLENGE (S3.24),
     232                 :             :  * and ADD_ONION (S3.27). See also sections 2.1 and 2.3.
     233                 :             :  */
     234                 :          27 : std::map<std::string,std::string> ParseTorReplyMapping(const std::string &s)
     235                 :             : {
     236                 :          27 :     std::map<std::string,std::string> mapping;
     237                 :          27 :     size_t ptr=0;
     238         [ +  + ]:          58 :     while (ptr < s.size()) {
     239                 :          38 :         std::string key, value;
     240   [ +  +  +  +  :         246 :         while (ptr < s.size() && s[ptr] != '=' && s[ptr] != ' ') {
                   +  + ]
     241         [ +  - ]:         208 :             key.push_back(s[ptr]);
     242                 :         208 :             ++ptr;
     243                 :             :         }
     244         [ +  + ]:          38 :         if (ptr == s.size()) // unexpected end of line
     245                 :           1 :             return std::map<std::string,std::string>();
     246         [ +  + ]:          37 :         if (s[ptr] == ' ') // The remaining string is an OptArguments
     247                 :             :             break;
     248                 :          32 :         ++ptr; // skip '='
     249   [ -  +  +  + ]:          32 :         if (ptr < s.size() && s[ptr] == '"') { // Quoted string
     250                 :          18 :             ++ptr; // skip opening '"'
     251                 :          18 :             bool escape_next = false;
     252   [ +  +  +  +  :         224 :             while (ptr < s.size() && (escape_next || s[ptr] != '"')) {
                   +  + ]
     253                 :             :                 // Repeated backslashes must be interpreted as pairs
     254   [ +  +  +  + ]:         206 :                 escape_next = (s[ptr] == '\\' && !escape_next);
     255         [ +  - ]:         206 :                 value.push_back(s[ptr]);
     256                 :         206 :                 ++ptr;
     257                 :             :             }
     258         [ +  + ]:          18 :             if (ptr == s.size()) // unexpected end of line
     259                 :           1 :                 return std::map<std::string,std::string>();
     260                 :          17 :             ++ptr; // skip closing '"'
     261                 :             :             /**
     262                 :             :              * Unescape value. Per https://spec.torproject.org/control-spec section 2.1.1:
     263                 :             :              *
     264                 :             :              *   For future-proofing, controller implementers MAY use the following
     265                 :             :              *   rules to be compatible with buggy Tor implementations and with
     266                 :             :              *   future ones that implement the spec as intended:
     267                 :             :              *
     268                 :             :              *     Read \n \t \r and \0 ... \377 as C escapes.
     269                 :             :              *     Treat a backslash followed by any other character as that character.
     270                 :             :              */
     271                 :          17 :             std::string escaped_value;
     272         [ +  + ]:         183 :             for (size_t i = 0; i < value.size(); ++i) {
     273         [ +  + ]:         166 :                 if (value[i] == '\\') {
     274                 :             :                     // This will always be valid, because if the QuotedString
     275                 :             :                     // ended in an odd number of backslashes, then the parser
     276                 :             :                     // would already have returned above, due to a missing
     277                 :             :                     // terminating double-quote.
     278                 :          23 :                     ++i;
     279         [ +  + ]:          23 :                     if (value[i] == 'n') {
     280         [ +  - ]:           1 :                         escaped_value.push_back('\n');
     281         [ +  + ]:          22 :                     } else if (value[i] == 't') {
     282         [ +  - ]:           1 :                         escaped_value.push_back('\t');
     283         [ +  + ]:          21 :                     } else if (value[i] == 'r') {
     284         [ +  - ]:           1 :                         escaped_value.push_back('\r');
     285   [ +  +  +  + ]:          20 :                     } else if ('0' <= value[i] && value[i] <= '7') {
     286                 :             :                         size_t j;
     287                 :             :                         // Octal escape sequences have a limit of three octal digits,
     288                 :             :                         // but terminate at the first character that is not a valid
     289                 :             :                         // octal digit if encountered sooner.
     290   [ +  +  +  +  :          21 :                         for (j = 1; j < 3 && (i+j) < value.size() && '0' <= value[i+j] && value[i+j] <= '7'; ++j) {}
             +  -  +  + ]
     291                 :             :                         // Tor restricts first digit to 0-3 for three-digit octals.
     292                 :             :                         // A leading digit of 4-7 would therefore be interpreted as
     293                 :             :                         // a two-digit octal.
     294   [ +  +  +  + ]:          11 :                         if (j == 3 && value[i] > '3') {
     295                 :           1 :                             j--;
     296                 :             :                         }
     297                 :          11 :                         const auto end{i + j};
     298                 :          11 :                         uint8_t val{0};
     299         [ +  + ]:          31 :                         while (i < end) {
     300                 :          20 :                             val *= 8;
     301                 :          20 :                             val += value[i++] - '0';
     302                 :             :                         }
     303         [ +  - ]:          11 :                         escaped_value.push_back(char(val));
     304                 :             :                         // Account for automatic incrementing at loop end
     305                 :          11 :                         --i;
     306                 :             :                     } else {
     307         [ +  - ]:           9 :                         escaped_value.push_back(value[i]);
     308                 :             :                     }
     309                 :             :                 } else {
     310         [ +  - ]:         143 :                     escaped_value.push_back(value[i]);
     311                 :             :                 }
     312                 :             :             }
     313         [ +  - ]:          34 :             value = escaped_value;
     314                 :          17 :         } else { // Unquoted value. Note that values can contain '=' at will, just no spaces
     315   [ +  +  +  + ]:         132 :             while (ptr < s.size() && s[ptr] != ' ') {
     316         [ +  - ]:         118 :                 value.push_back(s[ptr]);
     317                 :         118 :                 ++ptr;
     318                 :             :             }
     319                 :             :         }
     320   [ +  +  +  - ]:          31 :         if (ptr < s.size() && s[ptr] == ' ')
     321                 :          11 :             ++ptr; // skip ' ' after key=value
     322   [ +  -  +  - ]:          62 :         mapping[key] = value;
     323                 :          38 :     }
     324                 :          25 :     return mapping;
     325                 :          27 : }
     326                 :             : 
     327                 :           1 : TorController::TorController(struct event_base* _base, const std::string& tor_control_center, const CService& target):
     328                 :           1 :     base(_base),
     329   [ +  -  +  - ]:           1 :     m_tor_control_center(tor_control_center), conn(base), reconnect(true), reconnect_timeout(RECONNECT_TIMEOUT_START),
     330   [ +  -  +  - ]:           1 :     m_target(target)
     331                 :             : {
     332         [ +  - ]:           1 :     reconnect_ev = event_new(base, -1, 0, reconnect_cb, this);
     333         [ -  + ]:           1 :     if (!reconnect_ev)
     334         [ #  # ]:           0 :         LogPrintf("tor: Failed to create event for reconnection: out of memory?\n");
     335                 :             :     // Start connection attempts immediately
     336   [ +  -  +  -  :           1 :     if (!conn.Connect(m_tor_control_center, std::bind(&TorController::connected_cb, this, std::placeholders::_1),
                   -  + ]
     337         [ +  - ]:           1 :          std::bind(&TorController::disconnected_cb, this, std::placeholders::_1) )) {
     338         [ #  # ]:           0 :         LogPrintf("tor: Initiating connection to Tor control port %s failed\n", m_tor_control_center);
     339                 :             :     }
     340                 :             :     // Read service private key if cached
     341   [ +  -  +  - ]:           1 :     std::pair<bool,std::string> pkf = ReadBinaryFile(GetPrivateKeyFile());
     342         [ -  + ]:           1 :     if (pkf.first) {
     343   [ #  #  #  #  :           0 :         LogDebug(BCLog::TOR, "Reading cached private key from %s\n", fs::PathToString(GetPrivateKeyFile()));
             #  #  #  # ]
     344         [ -  - ]:           1 :         private_key = pkf.second;
     345                 :             :     }
     346                 :           1 : }
     347                 :             : 
     348                 :           1 : TorController::~TorController()
     349                 :             : {
     350         [ +  - ]:           1 :     if (reconnect_ev) {
     351                 :           1 :         event_free(reconnect_ev);
     352                 :           1 :         reconnect_ev = nullptr;
     353                 :             :     }
     354         [ -  + ]:           1 :     if (service.IsValid()) {
     355                 :           0 :         RemoveLocal(service);
     356                 :             :     }
     357                 :           1 : }
     358                 :             : 
     359                 :           0 : void TorController::get_socks_cb(TorControlConnection& _conn, const TorControlReply& reply)
     360                 :             : {
     361                 :             :     // NOTE: We can only get here if -onion is unset
     362         [ #  # ]:           0 :     std::string socks_location;
     363         [ #  # ]:           0 :     if (reply.code == TOR_REPLY_OK) {
     364         [ #  # ]:           0 :         for (const auto& line : reply.lines) {
     365         [ #  # ]:           0 :             if (line.starts_with("net/listeners/socks=")) {
     366         [ #  # ]:           0 :                 const std::string port_list_str = line.substr(20);
     367         [ #  # ]:           0 :                 std::vector<std::string> port_list = SplitString(port_list_str, ' ');
     368                 :             : 
     369         [ #  # ]:           0 :                 for (auto& portstr : port_list) {
     370         [ #  # ]:           0 :                     if (portstr.empty()) continue;
     371   [ #  #  #  #  :           0 :                     if ((portstr[0] == '"' || portstr[0] == '\'') && portstr.size() >= 2 && (*portstr.rbegin() == portstr[0])) {
             #  #  #  # ]
     372         [ #  # ]:           0 :                         portstr = portstr.substr(1, portstr.size() - 2);
     373         [ #  # ]:           0 :                         if (portstr.empty()) continue;
     374                 :             :                     }
     375         [ #  # ]:           0 :                     socks_location = portstr;
     376         [ #  # ]:           0 :                     if (portstr.starts_with("127.0.0.1:")) {
     377                 :             :                         // Prefer localhost - ignore other ports
     378                 :             :                         break;
     379                 :             :                     }
     380                 :             :                 }
     381                 :           0 :             }
     382                 :             :         }
     383         [ #  # ]:           0 :         if (!socks_location.empty()) {
     384   [ #  #  #  #  :           0 :             LogDebug(BCLog::TOR, "Get SOCKS port command yielded %s\n", socks_location);
                   #  # ]
     385                 :             :         } else {
     386         [ #  # ]:           0 :             LogPrintf("tor: Get SOCKS port command returned nothing\n");
     387                 :             :         }
     388         [ #  # ]:           0 :     } else if (reply.code == TOR_REPLY_UNRECOGNIZED) {
     389         [ #  # ]:           0 :         LogPrintf("tor: Get SOCKS port command failed with unrecognized command (You probably should upgrade Tor)\n");
     390                 :             :     } else {
     391         [ #  # ]:           0 :         LogPrintf("tor: Get SOCKS port command failed; error code %d\n", reply.code);
     392                 :             :     }
     393                 :             : 
     394         [ #  # ]:           0 :     CService resolved;
     395         [ #  # ]:           0 :     Assume(!resolved.IsValid());
     396         [ #  # ]:           0 :     if (!socks_location.empty()) {
     397   [ #  #  #  # ]:           0 :         resolved = LookupNumeric(socks_location, DEFAULT_TOR_SOCKS_PORT);
     398                 :             :     }
     399   [ #  #  #  # ]:           0 :     if (!resolved.IsValid()) {
     400                 :             :         // Fallback to old behaviour
     401   [ #  #  #  #  :           0 :         resolved = LookupNumeric("127.0.0.1", DEFAULT_TOR_SOCKS_PORT);
                   #  # ]
     402                 :             :     }
     403                 :             : 
     404         [ #  # ]:           0 :     Assume(resolved.IsValid());
     405   [ #  #  #  #  :           0 :     LogDebug(BCLog::TOR, "Configuring onion proxy for %s\n", resolved.ToStringAddrPort());
             #  #  #  # ]
     406                 :             : 
     407                 :             :     // With m_randomize_credentials = true, generates unique SOCKS credentials per proxy connection (e.g., Tor).
     408                 :             :     // Prevents connection correlation and enhances privacy by forcing different Tor circuits.
     409                 :             :     // Requires Tor's IsolateSOCKSAuth (default enabled) for effective isolation (see IsolateSOCKSAuth section in https://2019.www.torproject.org/docs/tor-manual.html.en).
     410                 :           0 :     Proxy addrOnion = Proxy(resolved, /*tor_stream_isolation=*/ true);
     411         [ #  # ]:           0 :     SetProxy(NET_ONION, addrOnion);
     412                 :             : 
     413   [ #  #  #  # ]:           0 :     const auto onlynets = gArgs.GetArgs("-onlynet");
     414                 :             : 
     415                 :           0 :     const bool onion_allowed_by_onlynet{
     416   [ #  #  #  # ]:           0 :         onlynets.empty() ||
     417         [ #  # ]:           0 :         std::any_of(onlynets.begin(), onlynets.end(), [](const auto& n) {
     418                 :           0 :             return ParseNetwork(n) == NET_ONION;
     419                 :           0 :         })};
     420                 :             : 
     421                 :           0 :     if (onion_allowed_by_onlynet) {
     422                 :             :         // If NET_ONION is reachable, then the below is a noop.
     423                 :             :         //
     424                 :             :         // If NET_ONION is not reachable, then none of -proxy or -onion was given.
     425                 :             :         // Since we are here, then -torcontrol and -torpassword were given.
     426         [ #  # ]:           0 :         g_reachable_nets.Add(NET_ONION);
     427                 :             :     }
     428                 :           0 : }
     429                 :             : 
     430                 :           0 : void TorController::add_onion_cb(TorControlConnection& _conn, const TorControlReply& reply)
     431                 :             : {
     432         [ #  # ]:           0 :     if (reply.code == TOR_REPLY_OK) {
     433         [ #  # ]:           0 :         LogDebug(BCLog::TOR, "ADD_ONION successful\n");
     434         [ #  # ]:           0 :         for (const std::string &s : reply.lines) {
     435                 :           0 :             std::map<std::string,std::string> m = ParseTorReplyMapping(s);
     436         [ #  # ]:           0 :             std::map<std::string,std::string>::iterator i;
     437   [ #  #  #  # ]:           0 :             if ((i = m.find("ServiceID")) != m.end())
     438         [ #  # ]:           0 :                 service_id = i->second;
     439   [ #  #  #  # ]:           0 :             if ((i = m.find("PrivateKey")) != m.end())
     440         [ #  # ]:           0 :                 private_key = i->second;
     441                 :           0 :         }
     442         [ #  # ]:           0 :         if (service_id.empty()) {
     443                 :           0 :             LogPrintf("tor: Error parsing ADD_ONION parameters:\n");
     444         [ #  # ]:           0 :             for (const std::string &s : reply.lines) {
     445         [ #  # ]:           0 :                 LogPrintf("    %s\n", SanitizeString(s));
     446                 :             :             }
     447                 :             :             return;
     448                 :             :         }
     449   [ #  #  #  #  :           0 :         service = LookupNumeric(std::string(service_id+".onion"), Params().GetDefaultPort());
                   #  # ]
     450         [ #  # ]:           0 :         LogInfo("Got tor service ID %s, advertising service %s\n", service_id, service.ToStringAddrPort());
     451   [ #  #  #  # ]:           0 :         if (WriteBinaryFile(GetPrivateKeyFile(), private_key)) {
     452   [ #  #  #  #  :           0 :             LogDebug(BCLog::TOR, "Cached service private key to %s\n", fs::PathToString(GetPrivateKeyFile()));
                   #  # ]
     453                 :             :         } else {
     454   [ #  #  #  # ]:           0 :             LogPrintf("tor: Error writing service private key to %s\n", fs::PathToString(GetPrivateKeyFile()));
     455                 :             :         }
     456                 :           0 :         AddLocal(service, LOCAL_MANUAL);
     457                 :             :         // ... onion requested - keep connection open
     458         [ #  # ]:           0 :     } else if (reply.code == TOR_REPLY_UNRECOGNIZED) {
     459                 :           0 :         LogPrintf("tor: Add onion failed with unrecognized command (You probably need to upgrade Tor)\n");
     460                 :             :     } else {
     461                 :           0 :         LogPrintf("tor: Add onion failed; error code %d\n", reply.code);
     462                 :             :     }
     463                 :             : }
     464                 :             : 
     465                 :           0 : void TorController::auth_cb(TorControlConnection& _conn, const TorControlReply& reply)
     466                 :             : {
     467         [ #  # ]:           0 :     if (reply.code == TOR_REPLY_OK) {
     468         [ #  # ]:           0 :         LogDebug(BCLog::TOR, "Authentication successful\n");
     469                 :             : 
     470                 :             :         // Now that we know Tor is running setup the proxy for onion addresses
     471                 :             :         // if -onion isn't set to something else.
     472   [ #  #  #  #  :           0 :         if (gArgs.GetArg("-onion", "") == "") {
                   #  # ]
     473   [ #  #  #  # ]:           0 :             _conn.Command("GETINFO net/listeners/socks", std::bind(&TorController::get_socks_cb, this, std::placeholders::_1, std::placeholders::_2));
     474                 :             :         }
     475                 :             : 
     476                 :             :         // Finally - now create the service
     477         [ #  # ]:           0 :         if (private_key.empty()) { // No private key, generate one
     478                 :           0 :             private_key = "NEW:ED25519-V3"; // Explicitly request key type - see issue #9214
     479                 :             :         }
     480                 :             :         // Request onion service, redirect port.
     481                 :             :         // Note that the 'virtual' port is always the default port to avoid decloaking nodes using other ports.
     482   [ #  #  #  #  :           0 :         _conn.Command(strprintf("ADD_ONION %s Port=%i,%s", private_key, Params().GetDefaultPort(), m_target.ToStringAddrPort()),
             #  #  #  # ]
     483                 :           0 :             std::bind(&TorController::add_onion_cb, this, std::placeholders::_1, std::placeholders::_2));
     484                 :             :     } else {
     485                 :           0 :         LogPrintf("tor: Authentication failed\n");
     486                 :             :     }
     487                 :           0 : }
     488                 :             : 
     489                 :             : /** Compute Tor SAFECOOKIE response.
     490                 :             :  *
     491                 :             :  *    ServerHash is computed as:
     492                 :             :  *      HMAC-SHA256("Tor safe cookie authentication server-to-controller hash",
     493                 :             :  *                  CookieString | ClientNonce | ServerNonce)
     494                 :             :  *    (with the HMAC key as its first argument)
     495                 :             :  *
     496                 :             :  *    After a controller sends a successful AUTHCHALLENGE command, the
     497                 :             :  *    next command sent on the connection must be an AUTHENTICATE command,
     498                 :             :  *    and the only authentication string which that AUTHENTICATE command
     499                 :             :  *    will accept is:
     500                 :             :  *
     501                 :             :  *      HMAC-SHA256("Tor safe cookie authentication controller-to-server hash",
     502                 :             :  *                  CookieString | ClientNonce | ServerNonce)
     503                 :             :  *
     504                 :             :  */
     505                 :           0 : static std::vector<uint8_t> ComputeResponse(const std::string &key, const std::vector<uint8_t> &cookie,  const std::vector<uint8_t> &clientNonce, const std::vector<uint8_t> &serverNonce)
     506                 :             : {
     507                 :           0 :     CHMAC_SHA256 computeHash((const uint8_t*)key.data(), key.size());
     508                 :           0 :     std::vector<uint8_t> computedHash(CHMAC_SHA256::OUTPUT_SIZE, 0);
     509         [ #  # ]:           0 :     computeHash.Write(cookie.data(), cookie.size());
     510         [ #  # ]:           0 :     computeHash.Write(clientNonce.data(), clientNonce.size());
     511         [ #  # ]:           0 :     computeHash.Write(serverNonce.data(), serverNonce.size());
     512         [ #  # ]:           0 :     computeHash.Finalize(computedHash.data());
     513                 :           0 :     return computedHash;
     514                 :           0 : }
     515                 :             : 
     516                 :           0 : void TorController::authchallenge_cb(TorControlConnection& _conn, const TorControlReply& reply)
     517                 :             : {
     518         [ #  # ]:           0 :     if (reply.code == TOR_REPLY_OK) {
     519         [ #  # ]:           0 :         LogDebug(BCLog::TOR, "SAFECOOKIE authentication challenge successful\n");
     520                 :           0 :         std::pair<std::string,std::string> l = SplitTorReplyLine(reply.lines[0]);
     521         [ #  # ]:           0 :         if (l.first == "AUTHCHALLENGE") {
     522         [ #  # ]:           0 :             std::map<std::string,std::string> m = ParseTorReplyMapping(l.second);
     523         [ #  # ]:           0 :             if (m.empty()) {
     524   [ #  #  #  # ]:           0 :                 LogPrintf("tor: Error parsing AUTHCHALLENGE parameters: %s\n", SanitizeString(l.second));
     525                 :           0 :                 return;
     526                 :             :             }
     527   [ #  #  #  #  :           0 :             std::vector<uint8_t> serverHash = ParseHex(m["SERVERHASH"]);
                   #  # ]
     528   [ #  #  #  #  :           0 :             std::vector<uint8_t> serverNonce = ParseHex(m["SERVERNONCE"]);
                   #  # ]
     529   [ #  #  #  #  :           0 :             LogDebug(BCLog::TOR, "AUTHCHALLENGE ServerHash %s ServerNonce %s\n", HexStr(serverHash), HexStr(serverNonce));
          #  #  #  #  #  
                      # ]
     530         [ #  # ]:           0 :             if (serverNonce.size() != 32) {
     531         [ #  # ]:           0 :                 LogPrintf("tor: ServerNonce is not 32 bytes, as required by spec\n");
     532                 :             :                 return;
     533                 :             :             }
     534                 :             : 
     535         [ #  # ]:           0 :             std::vector<uint8_t> computedServerHash = ComputeResponse(TOR_SAFE_SERVERKEY, cookie, clientNonce, serverNonce);
     536         [ #  # ]:           0 :             if (computedServerHash != serverHash) {
     537   [ #  #  #  #  :           0 :                 LogPrintf("tor: ServerHash %s does not match expected ServerHash %s\n", HexStr(serverHash), HexStr(computedServerHash));
                   #  # ]
     538                 :           0 :                 return;
     539                 :             :             }
     540                 :             : 
     541         [ #  # ]:           0 :             std::vector<uint8_t> computedClientHash = ComputeResponse(TOR_SAFE_CLIENTKEY, cookie, clientNonce, serverNonce);
     542   [ #  #  #  #  :           0 :             _conn.Command("AUTHENTICATE " + HexStr(computedClientHash), std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
             #  #  #  # ]
     543                 :           0 :         } else {
     544         [ #  # ]:           0 :             LogPrintf("tor: Invalid reply to AUTHCHALLENGE\n");
     545                 :             :         }
     546                 :           0 :     } else {
     547                 :           0 :         LogPrintf("tor: SAFECOOKIE authentication challenge failed\n");
     548                 :             :     }
     549                 :             : }
     550                 :             : 
     551                 :           0 : void TorController::protocolinfo_cb(TorControlConnection& _conn, const TorControlReply& reply)
     552                 :             : {
     553         [ #  # ]:           0 :     if (reply.code == TOR_REPLY_OK) {
     554                 :           0 :         std::set<std::string> methods;
     555                 :           0 :         std::string cookiefile;
     556                 :             :         /*
     557                 :             :          * 250-AUTH METHODS=COOKIE,SAFECOOKIE COOKIEFILE="/home/x/.tor/control_auth_cookie"
     558                 :             :          * 250-AUTH METHODS=NULL
     559                 :             :          * 250-AUTH METHODS=HASHEDPASSWORD
     560                 :             :          */
     561         [ #  # ]:           0 :         for (const std::string &s : reply.lines) {
     562         [ #  # ]:           0 :             std::pair<std::string,std::string> l = SplitTorReplyLine(s);
     563         [ #  # ]:           0 :             if (l.first == "AUTH") {
     564         [ #  # ]:           0 :                 std::map<std::string,std::string> m = ParseTorReplyMapping(l.second);
     565         [ #  # ]:           0 :                 std::map<std::string,std::string>::iterator i;
     566   [ #  #  #  # ]:           0 :                 if ((i = m.find("METHODS")) != m.end()) {
     567         [ #  # ]:           0 :                     std::vector<std::string> m_vec = SplitString(i->second, ',');
     568         [ #  # ]:           0 :                     methods = std::set<std::string>(m_vec.begin(), m_vec.end());
     569                 :           0 :                 }
     570   [ #  #  #  # ]:           0 :                 if ((i = m.find("COOKIEFILE")) != m.end())
     571         [ #  # ]:           0 :                     cookiefile = i->second;
     572         [ #  # ]:           0 :             } else if (l.first == "VERSION") {
     573         [ #  # ]:           0 :                 std::map<std::string,std::string> m = ParseTorReplyMapping(l.second);
     574         [ #  # ]:           0 :                 std::map<std::string,std::string>::iterator i;
     575   [ #  #  #  # ]:           0 :                 if ((i = m.find("Tor")) != m.end()) {
     576   [ #  #  #  #  :           0 :                     LogDebug(BCLog::TOR, "Connected to Tor version %s\n", i->second);
                   #  # ]
     577                 :             :                 }
     578                 :           0 :             }
     579                 :           0 :         }
     580         [ #  # ]:           0 :         for (const std::string &s : methods) {
     581   [ #  #  #  #  :           0 :             LogDebug(BCLog::TOR, "Supported authentication method: %s\n", s);
                   #  # ]
     582                 :             :         }
     583                 :             :         // Prefer NULL, otherwise SAFECOOKIE. If a password is provided, use HASHEDPASSWORD
     584                 :             :         /* Authentication:
     585                 :             :          *   cookie:   hex-encoded ~/.tor/control_auth_cookie
     586                 :             :          *   password: "password"
     587                 :             :          */
     588   [ #  #  #  #  :           0 :         std::string torpassword = gArgs.GetArg("-torpassword", "");
                   #  # ]
     589         [ #  # ]:           0 :         if (!torpassword.empty()) {
     590   [ #  #  #  # ]:           0 :             if (methods.count("HASHEDPASSWORD")) {
     591   [ #  #  #  #  :           0 :                 LogDebug(BCLog::TOR, "Using HASHEDPASSWORD authentication\n");
                   #  # ]
     592   [ #  #  #  #  :           0 :                 ReplaceAll(torpassword, "\"", "\\\"");
                   #  # ]
     593   [ #  #  #  #  :           0 :                 _conn.Command("AUTHENTICATE \"" + torpassword + "\"", std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
                   #  # ]
     594                 :             :             } else {
     595         [ #  # ]:           0 :                 LogPrintf("tor: Password provided with -torpassword, but HASHEDPASSWORD authentication is not available\n");
     596                 :             :             }
     597   [ #  #  #  # ]:           0 :         } else if (methods.count("NULL")) {
     598   [ #  #  #  #  :           0 :             LogDebug(BCLog::TOR, "Using NULL authentication\n");
                   #  # ]
     599   [ #  #  #  #  :           0 :             _conn.Command("AUTHENTICATE", std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
                   #  # ]
     600   [ #  #  #  # ]:           0 :         } else if (methods.count("SAFECOOKIE")) {
     601                 :             :             // Cookie: hexdump -e '32/1 "%02x""\n"'  ~/.tor/control_auth_cookie
     602   [ #  #  #  #  :           0 :             LogDebug(BCLog::TOR, "Using SAFECOOKIE authentication, reading cookie authentication from %s\n", cookiefile);
                   #  # ]
     603   [ #  #  #  # ]:           0 :             std::pair<bool,std::string> status_cookie = ReadBinaryFile(fs::PathFromString(cookiefile), TOR_COOKIE_SIZE);
     604   [ #  #  #  # ]:           0 :             if (status_cookie.first && status_cookie.second.size() == TOR_COOKIE_SIZE) {
     605                 :             :                 // _conn.Command("AUTHENTICATE " + HexStr(status_cookie.second), std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
     606   [ #  #  #  # ]:           0 :                 cookie = std::vector<uint8_t>(status_cookie.second.begin(), status_cookie.second.end());
     607         [ #  # ]:           0 :                 clientNonce = std::vector<uint8_t>(TOR_NONCE_SIZE, 0);
     608                 :           0 :                 GetRandBytes(clientNonce);
     609   [ #  #  #  #  :           0 :                 _conn.Command("AUTHCHALLENGE SAFECOOKIE " + HexStr(clientNonce), std::bind(&TorController::authchallenge_cb, this, std::placeholders::_1, std::placeholders::_2));
             #  #  #  # ]
     610                 :             :             } else {
     611         [ #  # ]:           0 :                 if (status_cookie.first) {
     612         [ #  # ]:           0 :                     LogPrintf("tor: Authentication cookie %s is not exactly %i bytes, as is required by the spec\n", cookiefile, TOR_COOKIE_SIZE);
     613                 :             :                 } else {
     614         [ #  # ]:           0 :                     LogPrintf("tor: Authentication cookie %s could not be opened (check permissions)\n", cookiefile);
     615                 :             :                 }
     616                 :             :             }
     617   [ #  #  #  # ]:           0 :         } else if (methods.count("HASHEDPASSWORD")) {
     618         [ #  # ]:           0 :             LogPrintf("tor: The only supported authentication mechanism left is password, but no password provided with -torpassword\n");
     619                 :             :         } else {
     620         [ #  # ]:           0 :             LogPrintf("tor: No supported authentication method\n");
     621                 :             :         }
     622                 :           0 :     } else {
     623                 :           0 :         LogPrintf("tor: Requesting protocol info failed\n");
     624                 :             :     }
     625                 :           0 : }
     626                 :             : 
     627                 :           0 : void TorController::connected_cb(TorControlConnection& _conn)
     628                 :             : {
     629                 :           0 :     reconnect_timeout = RECONNECT_TIMEOUT_START;
     630                 :             :     // First send a PROTOCOLINFO command to figure out what authentication is expected
     631   [ #  #  #  #  :           0 :     if (!_conn.Command("PROTOCOLINFO 1", std::bind(&TorController::protocolinfo_cb, this, std::placeholders::_1, std::placeholders::_2)))
                   #  # ]
     632                 :           0 :         LogPrintf("tor: Error sending initial protocolinfo command\n");
     633                 :           0 : }
     634                 :             : 
     635                 :           1 : void TorController::disconnected_cb(TorControlConnection& _conn)
     636                 :             : {
     637                 :             :     // Stop advertising service when disconnected
     638         [ -  + ]:           1 :     if (service.IsValid())
     639                 :           0 :         RemoveLocal(service);
     640                 :           1 :     service = CService();
     641         [ +  - ]:           1 :     if (!reconnect)
     642                 :             :         return;
     643                 :             : 
     644         [ +  - ]:           1 :     LogDebug(BCLog::TOR, "Not connected to Tor control port %s, retrying in %.2f s\n",
     645                 :             :              m_tor_control_center, reconnect_timeout);
     646                 :             : 
     647                 :             :     // Single-shot timer for reconnect. Use exponential backoff with a maximum.
     648                 :           1 :     struct timeval time = MillisToTimeval(int64_t(reconnect_timeout * 1000.0));
     649         [ +  - ]:           1 :     if (reconnect_ev)
     650                 :           1 :         event_add(reconnect_ev, &time);
     651                 :             : 
     652         [ +  - ]:           2 :     reconnect_timeout = std::min(reconnect_timeout * RECONNECT_TIMEOUT_EXP, RECONNECT_TIMEOUT_MAX);
     653                 :             : }
     654                 :             : 
     655                 :           0 : void TorController::Reconnect()
     656                 :             : {
     657                 :             :     /* Try to reconnect and reestablish if we get booted - for example, Tor
     658                 :             :      * may be restarting.
     659                 :             :      */
     660   [ #  #  #  #  :           0 :     if (!conn.Connect(m_tor_control_center, std::bind(&TorController::connected_cb, this, std::placeholders::_1),
                   #  # ]
     661                 :           0 :          std::bind(&TorController::disconnected_cb, this, std::placeholders::_1) )) {
     662                 :           0 :         LogPrintf("tor: Re-initiating connection to Tor control port %s failed\n", m_tor_control_center);
     663                 :             :     }
     664                 :           0 : }
     665                 :             : 
     666                 :           1 : fs::path TorController::GetPrivateKeyFile()
     667                 :             : {
     668         [ +  - ]:           3 :     return gArgs.GetDataDirNet() / "onion_v3_private_key";
     669                 :             : }
     670                 :             : 
     671                 :           0 : void TorController::reconnect_cb(evutil_socket_t fd, short what, void *arg)
     672                 :             : {
     673                 :           0 :     TorController *self = static_cast<TorController*>(arg);
     674                 :           0 :     self->Reconnect();
     675                 :           0 : }
     676                 :             : 
     677                 :             : /****** Thread ********/
     678                 :             : static struct event_base *gBase;
     679                 :             : static std::thread torControlThread;
     680                 :             : 
     681                 :           1 : static void TorControlThread(CService onion_service_target)
     682                 :             : {
     683   [ +  -  +  - ]:           2 :     TorController ctrl(gBase, gArgs.GetArg("-torcontrol", DEFAULT_TOR_CONTROL), onion_service_target);
     684                 :             : 
     685         [ +  - ]:           1 :     event_base_dispatch(gBase);
     686                 :           1 : }
     687                 :             : 
     688                 :           1 : void StartTorControl(CService onion_service_target)
     689                 :             : {
     690         [ -  + ]:           1 :     assert(!gBase);
     691                 :             : #ifdef WIN32
     692                 :             :     evthread_use_windows_threads();
     693                 :             : #else
     694                 :           1 :     evthread_use_pthreads();
     695                 :             : #endif
     696                 :           1 :     gBase = event_base_new();
     697         [ -  + ]:           1 :     if (!gBase) {
     698                 :           0 :         LogPrintf("tor: Unable to create event_base\n");
     699                 :           0 :         return;
     700                 :             :     }
     701                 :             : 
     702         [ +  - ]:           4 :     torControlThread = std::thread(&util::TraceThread, "torcontrol", [onion_service_target] {
     703         [ +  - ]:           1 :         TorControlThread(onion_service_target);
     704         [ +  - ]:           2 :     });
     705                 :             : }
     706                 :             : 
     707                 :        1066 : void InterruptTorControl()
     708                 :             : {
     709         [ +  + ]:        1066 :     if (gBase) {
     710                 :           1 :         LogPrintf("tor: Thread interrupt\n");
     711                 :           1 :         event_base_once(gBase, -1, EV_TIMEOUT, [](evutil_socket_t, short, void*) {
     712                 :             :             event_base_loopbreak(gBase);
     713                 :             :         }, nullptr, nullptr);
     714                 :             :     }
     715                 :        1066 : }
     716                 :             : 
     717                 :        1066 : void StopTorControl()
     718                 :             : {
     719         [ +  + ]:        1066 :     if (gBase) {
     720                 :           1 :         torControlThread.join();
     721                 :           1 :         event_base_free(gBase);
     722                 :           1 :         gBase = nullptr;
     723                 :             :     }
     724                 :        1066 : }
     725                 :             : 
     726                 :          15 : CService DefaultOnionServiceTarget(uint16_t port)
     727                 :             : {
     728                 :          15 :     struct in_addr onion_service_target;
     729                 :          15 :     onion_service_target.s_addr = htonl(INADDR_LOOPBACK);
     730                 :          15 :     return {onion_service_target, port};
     731                 :             : }
        

Generated by: LCOV version 2.0-1