251
252/** Parse reply arguments in the form 'METHODS=COOKIE,SAFECOOKIE COOKIEFILE=".../control_auth_cookie"'.
253 * Returns a map of keys to values, or an empty map if there was an error.
254 * Grammar is implicitly defined in https://spec.torproject.org/control-spec by
255 * the server reply formats for PROTOCOLINFO (S3.21), AUTHCHALLENGE (S3.24),
256 * and ADD_ONION (S3.27). See also sections 2.1 and 2.3.
257 */
258std::map<std::string,std::string> ParseTorReplyMapping(const std::string &s)
259{
260    std::map<std::string,std::string> mapping;
261    size_t ptr=0;
262    while (ptr < s.size()) {
263        std::string key, value;
264        while (ptr < s.size() && s[ptr] != '=' && s[ptr] != ' ') {
265            key.push_back(s[ptr]);
266            ++ptr;
267        }
268        if (ptr == s.size()) // unexpected end of line
269            return std::map<std::string,std::string>();
270        if (s[ptr] == ' ') // The remaining string is an OptArguments
271            break;
272        ++ptr; // skip '='
273        if (ptr < s.size() && s[ptr] == '"') { // Quoted string
274            ++ptr; // skip opening '"'
275            bool escape_next = false;
276            while (ptr < s.size() && (escape_next || s[ptr] != '"')) {
277                // Repeated backslashes must be interpreted as pairs
278                escape_next = (s[ptr] == '\\' && !escape_next);
279                value.push_back(s[ptr]);
280                ++ptr;
281            }
282            if (ptr == s.size()) // unexpected end of line
283                return std::map<std::string,std::string>();
284            ++ptr; // skip closing '"'
285            /**
286             * Unescape value. Per https://spec.torproject.org/control-spec section 2.1.1:
287             *
288             *   For future-proofing, controller implementers MAY use the following
289             *   rules to be compatible with buggy Tor implementations and with
290             *   future ones that implement the spec as intended:
291             *
292             *     Read \n \t \r and \0 ... \377 as C escapes.
293             *     Treat a backslash followed by any other character as that character.
294             */
295            std::string escaped_value;
296            for (size_t i = 0; i < value.size(); ++i) {
297                if (value[i] == '\\') {
298                    // This will always be valid, because if the QuotedString
299                    // ended in an odd number of backslashes, then the parser
300                    // would already have returned above, due to a missing
301                    // terminating double-quote.
302                    ++i;
303                    if (value[i] == 'n') {
304                        escaped_value.push_back('\n');
305                    } else if (value[i] == 't') {
306                        escaped_value.push_back('\t');
307                    } else if (value[i] == 'r') {
308                        escaped_value.push_back('\r');
309                    } else if ('0' <= value[i] && value[i] <= '7') {
310                        size_t j;
311                        // Octal escape sequences have a limit of three octal digits,
312                        // but terminate at the first character that is not a valid
313                        // octal digit if encountered sooner.
314                        for (j = 1; j < 3 && (i+j) < value.size() && '0' <= value[i+j] && value[i+j] <= '7'; ++j) {}
315                        // Tor restricts first digit to 0-3 for three-digit octals.
316                        // A leading digit of 4-7 would therefore be interpreted as
317                        // a two-digit octal.
318                        if (j == 3 && value[i] > '3') {
319                            j--;
320                        }
321                        const auto end{i + j};
322                        uint8_t val{0};
323                        while (i < end) {
324                            val *= 8;
325                            val += value[i++] - '0';
326                        }
327                        escaped_value.push_back(char(val));
328                        // Account for automatic incrementing at loop end
329                        --i;
330                    } else {
331                        escaped_value.push_back(value[i]);
332                    }
333                } else {
334                    escaped_value.push_back(value[i]);
335                }
336            }
337            value = escaped_value;
338        } else { // Unquoted value. Note that values can contain '=' at will, just no spaces
339            while (ptr < s.size() && s[ptr] != ' ') {
340                value.push_back(s[ptr]);
341                ++ptr;
342            }
343        }
344        if (ptr < s.size() && s[ptr] == ' ')
345            ++ptr; // skip ' ' after key=value
346        mapping[key] = value;
347    }
348    return mapping;
349}
350
351TorController::TorController(const std::string& tor_control_center, const CService& target)
352    : m_tor_control_center(tor_control_center),
353      m_conn(m_interrupt),
354      m_reconnect(true),
355      m_reconnect_timeout(RECONNECT_TIMEOUT_START),
356      m_target(target)
357{
358    // Read service private key if cached
359    std::pair<bool,std::string> pkf = ReadBinaryFile(GetPrivateKeyFile());
360    if (pkf.first) {
361        LogDebug(BCLog::TOR, "Reading cached private key from %s", fs::PathToString(GetPrivateKeyFile()));
362        m_private_key = pkf.second;
363    }
364    m_thread = std::thread(&util::TraceThread, "torcontrol", [this] { ThreadControl(); });
365}
366
367TorController::~TorController()
368{
369    Interrupt();
370    Join();
371    if (m_service.IsValid()) {
372        RemoveLocal(m_service);
373    }
374}
375
376void TorController::Interrupt()
377{
378    m_reconnect = false;
379    m_interrupt();
380}
381
382void TorController::Join()
383{
384    if (m_thread.joinable()) {
385        m_thread.join();
386    }
387}
388
389void TorController::ThreadControl()
390{
391    LogDebug(BCLog::TOR, "Entering Tor control thread");
392
393    while (!m_interrupt) {
394        LogDebug(BCLog::TOR, "Attempting to connect to Tor control port %s", m_tor_control_center);
395        if (m_conn.Connect(m_tor_control_center)) {
396            connected_cb(m_conn);
397            while (!m_interrupt) {
398                if (!m_conn.WaitForData(std::chrono::seconds(1))) {
399                    if (m_conn.IsConnected()) continue;
400                    LogDebug(BCLog::TOR, "Lost connection to Tor control port");
401                    break;
402                }
403                if (!m_conn.ReceiveAndProcess()) break;
404            }
405        } else {
406            LogWarning("tor: Initiating connection to Tor control port %s failed", m_tor_control_center);
407        }
408        disconnected_cb(m_conn);
409    }
410    LogDebug(BCLog::TOR, "Exited Tor control thread");
411}
412
413void TorController::get_socks_cb(TorControlConnection& _conn, const TorControlReply& reply)
414{
415    // NOTE: We can only get here if -onion is unset
416    std::string socks_location;
417    if (reply.code == TOR_REPLY_OK) {
418        for (const auto& line : reply.lines) {
419            if (line.starts_with("net/listeners/socks=")) {
420                const std::string port_list_str = line.substr(20);
421                std::vector<std::string> port_list = SplitString(port_list_str, ' ');
422
423                for (auto& portstr : port_list) {
424                    if (portstr.empty()) continue;
425                    if ((portstr[0] == '"' || portstr[0] == '\'') && portstr.size() >= 2 && (*portstr.rbegin() == portstr[0])) {
426                        portstr = portstr.substr(1, portstr.size() - 2);
427                        if (portstr.empty()) continue;
428                    }
429                    socks_location = portstr;
430                    if (portstr.starts_with("127.0.0.1:")) {
431                        // Prefer localhost - ignore other ports
432                        break;
433                    }
434                }
435            }
436        }
437        if (!socks_location.empty()) {
438            LogDebug(BCLog::TOR, "Get SOCKS port command yielded %s", socks_location);
439        } else {
440            LogWarning("tor: Get SOCKS port command returned nothing");
441        }
442    } else if (reply.code == TOR_REPLY_UNRECOGNIZED) {
443        LogWarning("tor: Get SOCKS port command failed with unrecognized command (You probably should upgrade Tor)");
444    } else {
445        LogWarning("tor: Get SOCKS port command failed; error code %d", reply.code);
446    }
447
448    CService resolved;
449    Assume(!resolved.IsValid());
450    if (!socks_location.empty()) {
451        resolved = LookupNumeric(socks_location, DEFAULT_TOR_SOCKS_PORT);
452    }
453    if (!resolved.IsValid()) {
454        // Fallback to old behaviour
455        resolved = LookupNumeric("127.0.0.1", DEFAULT_TOR_SOCKS_PORT);
456    }
457
458    Assume(resolved.IsValid());
459    LogDebug(BCLog::TOR, "Configuring onion proxy for %s", resolved.ToStringAddrPort());
460
461    // Add Tor as proxy for .onion addresses.
462    // Enable stream isolation to prevent connection correlation and enhance privacy, by forcing a different Tor circuit for every connection.
463    // For this to work, the IsolateSOCKSAuth flag must be enabled on SOCKSPort (which is the default, see the IsolateSOCKSAuth section of Tor's manual page).
464    Proxy addrOnion = Proxy(resolved, /*tor_stream_isolation=*/ true);
465    SetProxy(NET_ONION, addrOnion);
466
467    const auto onlynets = gArgs.GetArgs("-onlynet");
468
469    const bool onion_allowed_by_onlynet{
470        onlynets.empty() ||
471        std::any_of(onlynets.begin(), onlynets.end(), [](const auto& n) {
472            return ParseNetwork(n) == NET_ONION;
473        })};
474
475    if (onion_allowed_by_onlynet) {
476        // If NET_ONION is reachable, then the below is a noop.
477        //
478        // If NET_ONION is not reachable, then none of -proxy or -onion was given.
479        // Since we are here, then -torcontrol and -torpassword were given.
480        g_reachable_nets.Add(NET_ONION);
481    }
482}
483
484static std::string MakeAddOnionCmd(const std::string& private_key, const std::string& target, bool enable_pow)
485{
486    // Note that the 'virtual' port is always the default port to avoid decloaking nodes using other ports.
487    return strprintf("ADD_ONION %s%s Port=%i,%s",
488                     private_key,
489                     enable_pow ? " PoWDefensesEnabled=1" : "",
490                     Params().GetDefaultPort(),
491                     target);
492}
493
494void TorController::add_onion_cb(TorControlConnection& _conn, const TorControlReply& reply, bool pow_was_enabled)
495{
496    if (reply.code == TOR_REPLY_OK) {
497        LogDebug(BCLog::TOR, "ADD_ONION successful (PoW defenses %s)", pow_was_enabled ? "enabled" : "disabled");
498        for (const std::string &s : reply.lines) {
499            std::map<std::string,std::string> m = ParseTorReplyMapping(s);
500            std::map<std::string,std::string>::iterator i;