Merge pull request #6639

58ef0ff doc: update docs for Tor listening (Wladimir J. van der Laan)
68ccdc4 doc: Mention Tor listening in release notes (Wladimir J. van der Laan)
09c1ae1 torcontrol improvements and fixes (Wladimir J. van der Laan)
2f796e5 Better error message if Tor version too old (Peter Todd)
8f4e67f net: Automatically create hidden service, listen on Tor (Wladimir J. van der Laan)

doc/files.md

@@ -12,6 +12,8 @@
 * fee_estimates.dat: stores statistics used to estimate minimum transaction fees and priorities required for confirmation; since 0.10.0
 * peers.dat: peer IP address database (custom format); since 0.7.0
 * wallet.dat: personal wallet (BDB) with keys and transactions
+* .cookie: session RPC authentication cookie (written at start when cookie authentication is used, deleted on shutdown): since 0.12.0
+* onion_private_key: cached Tor hidden service private key for `-listenonion`: since 0.12.0
 
 Only used in pre-0.8.0
 ---------------------

doc/release-notes.md

@@ -151,6 +151,23 @@ mining with the getblocktemplate protocol to a pool: this will affect you at
 the pool operator's discretion, which must be no later than BIP65 achieving its
 951/1001 status.
 
+Automatically listen on Tor
+----------------------------
+
+Starting with Tor version 0.2.7.1 it is possible, through Tor's control socket
+API, to create and destroy 'ephemeral' hidden services programmatically.
+Bitcoin Core has been updated to make use of this.
+
+This means that if Tor is running (and proper authorization is available),
+Bitcoin Core automatically creates a hidden service to listen on, without
+manual configuration. This will positively affect the number of available
+.onion nodes.
+
+This new feature is enabled by default if Bitcoin Core is listening, and
+a connection to Tor can be made. It can be configured with the `-listenonion`,
+`-torcontrol` and `-torpassword` settings. To show verbose debugging
+information, pass `-debug=tor`.
+
 0.12.0 Change log
 =================
 

doc/tor.md

@@ -87,3 +87,20 @@ If you only want to use Tor to reach onion addresses, but not use it as a proxy
 for normal IPv4/IPv6 communication, use:
 
 	./bitcoin -onion=127.0.0.1:9050 -externalip=57qr3yd1nyntf5k.onion -discover
+
+3. Automatically listen on Tor
+--------------------------------
+
+Starting with Tor version 0.2.7.1 it is possible, through Tor's control socket
+API, to create and destroy 'ephemeral' hidden services programmatically.
+Bitcoin Core has been updated to make use of this.
+
+This means that if Tor is running (and proper authorization is available),
+Bitcoin Core automatically creates a hidden service to listen on, without
+manual configuration. This will positively affect the number of available
+.onion nodes.
+
+This new feature is enabled by default if Bitcoin Core is listening, and
+a connection to Tor can be made. It can be configured with the `-listenonion`,
+`-torcontrol` and `-torpassword` settings. To show verbose debugging
+information, pass `-debug=tor`.

src/Makefile.am

@@ -151,6 +151,7 @@ BITCOIN_CORE_H = \
   threadsafety.h \
   timedata.h \
   tinyformat.h \
+  torcontrol.h \
   txdb.h \
   txmempool.h \
   ui_interface.h \
@@ -209,6 +210,7 @@ libbitcoin_server_a_SOURCES = \
   rpcserver.cpp \
   script/sigcache.cpp \
   timedata.cpp \
+  torcontrol.cpp \
   txdb.cpp \
   txmempool.cpp \
   validationinterface.cpp \

src/init.cpp

@@ -29,6 +29,7 @@
 #include "scheduler.h"
 #include "txdb.h"
 #include "txmempool.h"
+#include "torcontrol.h"
 #include "ui_interface.h"
 #include "util.h"
 #include "utilmoneystr.h"
@@ -160,6 +161,7 @@ void Interrupt(boost::thread_group& threadGroup)
     InterruptHTTPRPC();
     InterruptRPC();
     InterruptREST();
+    InterruptTorControl();
     threadGroup.interrupt_all();
 }
 
@@ -188,6 +190,7 @@ void Shutdown()
 #endif
     GenerateBitcoins(false, 0, Params());
     StopNode();
+    StopTorControl();
     UnregisterNodeSignals(GetNodeSignals());
 
     if (fFeeEstimatesInitialized)
@@ -348,6 +351,7 @@ std::string HelpMessage(HelpMessageMode mode)
     strUsage += HelpMessageOpt("-externalip=<ip>", _("Specify your own public address"));
     strUsage += HelpMessageOpt("-forcednsseed", strprintf(_("Always query for peer addresses via DNS lookup (default: %u)"), 0));
     strUsage += HelpMessageOpt("-listen", _("Accept connections from outside (default: 1 if no -proxy or -connect)"));
+    strUsage += HelpMessageOpt("-listenonion", strprintf(_("Automatically create Tor hidden service (default: %d)"), DEFAULT_LISTEN_ONION));
     strUsage += HelpMessageOpt("-maxconnections=<n>", strprintf(_("Maintain at most <n> connections to peers (default: %u)"), DEFAULT_MAX_PEER_CONNECTIONS));
     strUsage += HelpMessageOpt("-maxreceivebuffer=<n>", strprintf(_("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)"), 5000));
     strUsage += HelpMessageOpt("-maxsendbuffer=<n>", strprintf(_("Maximum per-connection send buffer, <n>*1000 bytes (default: %u)"), 1000));
@@ -359,6 +363,8 @@ std::string HelpMessage(HelpMessageMode mode)
     strUsage += HelpMessageOpt("-proxyrandomize", strprintf(_("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)"), 1));
     strUsage += HelpMessageOpt("-seednode=<ip>", _("Connect to a node to retrieve peer addresses, and disconnect"));
     strUsage += HelpMessageOpt("-timeout=<n>", strprintf(_("Specify connection timeout in milliseconds (minimum: 1, default: %d)"), DEFAULT_CONNECT_TIMEOUT));
+    strUsage += HelpMessageOpt("-torcontrol=<ip>:<port>", strprintf(_("Tor control port to use if onion listening enabled (default: %s)"), DEFAULT_TOR_CONTROL));
+    strUsage += HelpMessageOpt("-torpassword=<pass>", _("Tor control port password (default: empty)"));
 #ifdef USE_UPNP
 #if USE_UPNP
     strUsage += HelpMessageOpt("-upnp", _("Use UPnP to map the listening port (default: 1 when listening and no -proxy)"));
@@ -778,6 +784,8 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
             LogPrintf("%s: parameter interaction: -listen=0 -> setting -upnp=0\n", __func__);
         if (SoftSetBoolArg("-discover", false))
             LogPrintf("%s: parameter interaction: -listen=0 -> setting -discover=0\n", __func__);
+        if (SoftSetBoolArg("-listenonion", false))
+            LogPrintf("%s: parameter interaction: -listen=0 -> setting -listenonion=0\n", __func__);
     }
 
     if (mapArgs.count("-externalip")) {
@@ -1568,6 +1576,9 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
     LogPrintf("mapAddressBook.size() = %u\n",  pwalletMain ? pwalletMain->mapAddressBook.size() : 0);
 #endif
 
+    if (GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION))
+        StartTorControl(threadGroup, scheduler);
+
     StartNode(threadGroup, scheduler);
 
     // Monitor the chain, and alert if we get blocks much quicker or slower than expected

src/main.cpp

@@ -4059,9 +4059,11 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
                 CAddress addr = GetLocalAddress(&pfrom->addr);
                 if (addr.IsRoutable())
                 {
+                    LogPrintf("ProcessMessages: advertizing address %s\n", addr.ToString());
                     pfrom->PushAddress(addr);
                 } else if (IsPeerAddrLocalGood(pfrom)) {
                     addr.SetIP(pfrom->addrLocal);
+                    LogPrintf("ProcessMessages: advertizing address %s\n", addr.ToString());
                     pfrom->PushAddress(addr);
                 }
             }

src/net.cpp

@@ -216,6 +216,7 @@ void AdvertizeLocal(CNode *pnode)
         }
         if (addrLocal.IsRoutable())
         {
+            LogPrintf("AdvertizeLocal: advertizing address %s\n", addrLocal.ToString());
             pnode->PushAddress(addrLocal);
         }
     }
@@ -262,6 +263,14 @@ bool AddLocal(const CNetAddr &addr, int nScore)
     return AddLocal(CService(addr, GetListenPort()), nScore);
 }
 
+bool RemoveLocal(const CService& addr)
+{
+    LOCK(cs_mapLocalHost);
+    LogPrintf("RemoveLocal(%s)\n", addr.ToString());
+    mapLocalHost.erase(addr);
+    return true;
+}
+
 /** Make a particular network entirely off-limits (no automatic connects to it) */
 void SetLimited(enum Network net, bool fLimited)
 {

src/net.h

@@ -128,6 +128,7 @@ bool IsLimited(enum Network net);
 bool IsLimited(const CNetAddr& addr);
 bool AddLocal(const CService& addr, int nScore = LOCAL_NONE);
 bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
+bool RemoveLocal(const CService& addr);
 bool SeenLocal(const CService& addr);
 bool IsLocal(const CService& addr);
 bool GetLocal(CService &addr, const CNetAddr *paddrPeer = NULL);

src/netbase.cpp

@@ -227,10 +227,7 @@ bool LookupNumeric(const char *pszName, CService& addr, int portDefault)
     return Lookup(pszName, addr, portDefault, false);
 }
 
-/**
+struct timeval MillisToTimeval(int64_t nTimeout)
- * Convert milliseconds to a struct timeval for select.
- */
-struct timeval static MillisToTimeval(int64_t nTimeout)
 {
     struct timeval timeout;
     timeout.tv_sec  = nTimeout / 1000;

src/netbase.h

@@ -215,5 +215,9 @@ std::string NetworkErrorString(int err);
 bool CloseSocket(SOCKET& hSocket);
 /** Disable or enable blocking-mode for a socket */
 bool SetSocketNonBlocking(SOCKET& hSocket, bool fNonBlocking);
+/**
+ * Convert milliseconds to a struct timeval for e.g. select.
+ */
+struct timeval MillisToTimeval(int64_t nTimeout);
 
 #endif // BITCOIN_NETBASE_H

src/torcontrol.cpp

@@ -0,0 +1,685 @@
+#include "torcontrol.h"
+#include "utilstrencodings.h"
+#include "net.h"
+#include "util.h"
+#include "crypto/hmac_sha256.h"
+
+#include <vector>
+#include <deque>
+#include <set>
+#include <stdlib.h>
+
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/signals2/signal.hpp>
+#include <boost/foreach.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/replace.hpp>
+
+#include <event2/bufferevent.h>
+#include <event2/buffer.h>
+#include <event2/util.h>
+#include <event2/event.h>
+#include <event2/thread.h>
+
+/** Default control port */
+const std::string DEFAULT_TOR_CONTROL = "127.0.0.1:9051";
+/** Tor cookie size (from control-spec.txt) */
+static const int TOR_COOKIE_SIZE = 32;
+/** Size of client/server nonce for SAFECOOKIE */
+static const int TOR_NONCE_SIZE = 32;
+/** For computing serverHash in SAFECOOKIE */
+static const std::string TOR_SAFE_SERVERKEY = "Tor safe cookie authentication server-to-controller hash";
+/** For computing clientHash in SAFECOOKIE */
+static const std::string TOR_SAFE_CLIENTKEY = "Tor safe cookie authentication controller-to-server hash";
+/** Exponential backoff configuration - initial timeout in seconds */
+static const float RECONNECT_TIMEOUT_START = 1.0;
+/** Exponential backoff configuration - growth factor */
+static const float RECONNECT_TIMEOUT_EXP = 1.5;
+/** Maximum length for lines received on TorControlConnection.
+ * tor-control-spec.txt mentions that there is explicitly no limit defined to line length,
+ * this is belt-and-suspenders sanity limit to prevent memory exhaustion.
+ */
+static const int MAX_LINE_LENGTH = 100000;
+
+/****** Low-level TorControlConnection ********/
+
+/** Reply from Tor, can be single or multi-line */
+class TorControlReply
+{
+public:
+    TorControlReply() { Clear(); }
+
+    int code;
+    std::vector<std::string> lines;
+
+    void Clear()
+    {
+        code = 0;
+        lines.clear();
+    }
+};
+
+/** Low-level handling for Tor control connection.
+ * Speaks the SMTP-like protocol as defined in torspec/control-spec.txt
+ */
+class TorControlConnection
+{
+public:
+    typedef boost::function<void(TorControlConnection&)> ConnectionCB;
+    typedef boost::function<void(TorControlConnection &,const TorControlReply &)> ReplyHandlerCB;
+
+    /** Create a new TorControlConnection.
+     */
+    TorControlConnection(struct event_base *base);
+    ~TorControlConnection();
+
+    /**
+     * Connect to a Tor control port.
+     * target is address of the form host:port.
+     * connected is the handler that is called when connection is succesfully established.
+     * disconnected is a handler that is called when the connection is broken.
+     * Return true on success.
+     */
+    bool Connect(const std::string &target, const ConnectionCB& connected, const ConnectionCB& disconnected);
+
+    /**
+     * Disconnect from Tor control port.
+     */
+    bool Disconnect();
+
+    /** Send a command, register a handler for the reply.
+     * A trailing CRLF is automatically added.
+     * Return true on success.
+     */
+    bool Command(const std::string &cmd, const ReplyHandlerCB& reply_handler);
+
+    /** Response handlers for async replies */
+    boost::signals2::signal<void(TorControlConnection &,const TorControlReply &)> async_handler;
+private:
+    /** Callback when ready for use */
+    boost::function<void(TorControlConnection&)> connected;
+    /** Callback when connection lost */
+    boost::function<void(TorControlConnection&)> disconnected;
+    /** Libevent event base */
+    struct event_base *base;
+    /** Connection to control socket */
+    struct bufferevent *b_conn;
+    /** Message being received */
+    TorControlReply message;
+    /** Response handlers */
+    std::deque<ReplyHandlerCB> reply_handlers;
+
+    /** Libevent handlers: internal */
+    static void readcb(struct bufferevent *bev, void *ctx);
+    static void eventcb(struct bufferevent *bev, short what, void *ctx);
+};
+
+TorControlConnection::TorControlConnection(struct event_base *base):
+    base(base), b_conn(0)
+{
+}
+
+TorControlConnection::~TorControlConnection()
+{
+    if (b_conn)
+        bufferevent_free(b_conn);
+}
+
+void TorControlConnection::readcb(struct bufferevent *bev, void *ctx)
+{
+    TorControlConnection *self = (TorControlConnection*)ctx;
+    struct evbuffer *input = bufferevent_get_input(bev);
+    size_t n_read_out = 0;
+    char *line;
+    assert(input);
+    //  If there is not a whole line to read, evbuffer_readln returns NULL
+    while((line = evbuffer_readln(input, &n_read_out, EVBUFFER_EOL_CRLF)) != NULL)
+    {
+        std::string s(line, n_read_out);
+        free(line);
+        if (s.size() < 4) // Short line
+            continue;
+        // <status>(-|+| )<data><CRLF>
+        self->message.code = atoi(s.substr(0,3));
+        self->message.lines.push_back(s.substr(4));
+        char ch = s[3]; // '-','+' or ' '
+        if (ch == ' ') {
+            // Final line, dispatch reply and clean up
+            if (self->message.code >= 600) {
+                // Dispatch async notifications to async handler
+                // Synchronous and asynchronous messages are never interleaved
+                self->async_handler(*self, self->message);
+            } else {
+                if (!self->reply_handlers.empty()) {
+                    // Invoke reply handler with message
+                    self->reply_handlers.front()(*self, self->message);
+                    self->reply_handlers.pop_front();
+                } else {
+                    LogPrint("tor", "tor: Received unexpected sync reply %i\n", self->message.code);
+                }
+            }
+            self->message.Clear();
+        }
+    }
+    //  Check for size of buffer - protect against memory exhaustion with very long lines
+    //  Do this after evbuffer_readln to make sure all full lines have been
+    //  removed from the buffer. Everything left is an incomplete line.
+    if (evbuffer_get_length(input) > MAX_LINE_LENGTH) {
+        LogPrintf("tor: Disconnecting because MAX_LINE_LENGTH exceeded\n");
+        self->Disconnect();
+    }
+}
+
+void TorControlConnection::eventcb(struct bufferevent *bev, short what, void *ctx)
+{
+    TorControlConnection *self = (TorControlConnection*)ctx;
+    if (what & BEV_EVENT_CONNECTED) {
+        LogPrint("tor", "tor: Succesfully connected!\n");
+        self->connected(*self);
+    } else if (what & (BEV_EVENT_EOF|BEV_EVENT_ERROR)) {
+        if (what & BEV_EVENT_ERROR)
+            LogPrint("tor", "tor: Error connecting to Tor control socket\n");
+        else
+            LogPrint("tor", "tor: End of stream\n");
+        self->Disconnect();
+        self->disconnected(*self);
+    }
+}
+
+bool TorControlConnection::Connect(const std::string &target, const ConnectionCB& connected, const ConnectionCB& disconnected)
+{
+    if (b_conn)
+        Disconnect();
+    // Parse target address:port
+    struct sockaddr_storage connect_to_addr;
+    int connect_to_addrlen = sizeof(connect_to_addr);
+    if (evutil_parse_sockaddr_port(target.c_str(),
+        (struct sockaddr*)&connect_to_addr, &connect_to_addrlen)<0) {
+        LogPrintf("tor: Error parsing socket address %s\n", target);
+        return false;
+    }
+
+    // Create a new socket, set up callbacks and enable notification bits
+    b_conn = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
+    if (!b_conn)
+        return false;
+    bufferevent_setcb(b_conn, TorControlConnection::readcb, NULL, TorControlConnection::eventcb, this);
+    bufferevent_enable(b_conn, EV_READ|EV_WRITE);
+    this->connected = connected;
+    this->disconnected = disconnected;
+
+    // Finally, connect to target
+    if (bufferevent_socket_connect(b_conn, (struct sockaddr*)&connect_to_addr, connect_to_addrlen) < 0) {
+        LogPrintf("tor: Error connecting to address %s\n", target);
+        return false;
+    }
+    return true;
+}
+
+bool TorControlConnection::Disconnect()
+{
+    if (b_conn)
+        bufferevent_free(b_conn);
+    b_conn = 0;
+    return true;
+}
+
+bool TorControlConnection::Command(const std::string &cmd, const ReplyHandlerCB& reply_handler)
+{
+    if (!b_conn)
+        return false;
+    struct evbuffer *buf = bufferevent_get_output(b_conn);
+    if (!buf)
+        return false;
+    evbuffer_add(buf, cmd.data(), cmd.size());
+    evbuffer_add(buf, "\r\n", 2);
+    reply_handlers.push_back(reply_handler);
+    return true;
+}
+
+/****** General parsing utilities ********/
+
+/* Split reply line in the form 'AUTH METHODS=...' into a type
+ * 'AUTH' and arguments 'METHODS=...'.
+ */
+static std::pair<std::string,std::string> SplitTorReplyLine(const std::string &s)
+{
+    size_t ptr=0;
+    std::string type;
+    while (ptr < s.size() && s[ptr] != ' ') {
+        type.push_back(s[ptr]);
+        ++ptr;
+    }
+    if (ptr < s.size())
+        ++ptr; // skip ' '
+    return make_pair(type, s.substr(ptr));
+}
+
+/** Parse reply arguments in the form 'METHODS=COOKIE,SAFECOOKIE COOKIEFILE=".../control_auth_cookie"'.
+ */
+static std::map<std::string,std::string> ParseTorReplyMapping(const std::string &s)
+{
+    std::map<std::string,std::string> mapping;
+    size_t ptr=0;
+    while (ptr < s.size()) {
+        std::string key, value;
+        while (ptr < s.size() && s[ptr] != '=') {
+            key.push_back(s[ptr]);
+            ++ptr;
+        }
+        if (ptr == s.size()) // unexpected end of line
+            return std::map<std::string,std::string>();
+        ++ptr; // skip '='
+        if (ptr < s.size() && s[ptr] == '"') { // Quoted string
+            ++ptr; // skip '='
+            bool escape_next = false;
+            while (ptr < s.size() && (!escape_next && s[ptr] != '"')) {
+                escape_next = (s[ptr] == '\\');
+                value.push_back(s[ptr]);
+                ++ptr;
+            }
+            if (ptr == s.size()) // unexpected end of line
+                return std::map<std::string,std::string>();
+            ++ptr; // skip closing '"'
+            /* TODO: unescape value - according to the spec this depends on the
+             * context, some strings use C-LogPrintf style escape codes, some
+             * don't. So may be better handled at the call site.
+             */
+        } else { // Unquoted value. Note that values can contain '=' at will, just no spaces
+            while (ptr < s.size() && s[ptr] != ' ') {
+                value.push_back(s[ptr]);
+                ++ptr;
+            }
+        }
+        if (ptr < s.size() && s[ptr] == ' ')
+            ++ptr; // skip ' ' after key=value
+        mapping[key] = value;
+    }
+    return mapping;
+}
+
+/** Read full contents of a file and return them in a std::string.
+ * Returns a pair <status, string>.
+ * If an error occured, status will be false, otherwise status will be true and the data will be returned in string.
+ *
+ * @param maxsize Puts a maximum size limit on the file that is read. If the file is larger than this, truncated data
+ *         (with len > maxsize) will be returned.
+ */
+static std::pair<bool,std::string> ReadBinaryFile(const std::string &filename, size_t maxsize=std::numeric_limits<size_t>::max())
+{
+    FILE *f = fopen(filename.c_str(), "rb");
+    if (f == NULL)
+        return std::make_pair(false,"");
+    std::string retval;
+    char buffer[128];
+    size_t n;
+    while ((n=fread(buffer, 1, sizeof(buffer), f)) > 0) {
+        retval.append(buffer, buffer+n);
+        if (retval.size() > maxsize)
+            break;
+    }
+    fclose(f);
+    return std::make_pair(true,retval);
+}
+
+/** Write contents of std::string to a file.
+ * @return true on success.
+ */
+static bool WriteBinaryFile(const std::string &filename, const std::string &data)
+{
+    FILE *f = fopen(filename.c_str(), "wb");
+    if (f == NULL)
+        return false;
+    if (fwrite(data.data(), 1, data.size(), f) != data.size()) {
+        fclose(f);
+        return false;
+    }
+    fclose(f);
+    return true;
+}
+
+/****** Bitcoin specific TorController implementation ********/
+
+/** Controller that connects to Tor control socket, authenticate, then create
+ * and maintain a ephemeral hidden service.
+ */
+class TorController
+{
+public:
+    TorController(struct event_base* base, const std::string& target);
+    ~TorController();
+
+    /** Get name fo file to store private key in */
+    std::string GetPrivateKeyFile();
+
+    /** Reconnect, after getting disconnected */
+    void Reconnect();
+private:
+    struct event_base* base;
+    std::string target;
+    TorControlConnection conn;
+    std::string private_key;
+    std::string service_id;
+    bool reconnect;
+    struct event *reconnect_ev;
+    float reconnect_timeout;
+    CService service;
+    /** Cooie for SAFECOOKIE auth */
+    std::vector<uint8_t> cookie;
+    /** ClientNonce for SAFECOOKIE auth */
+    std::vector<uint8_t> clientNonce;
+
+    /** Callback for ADD_ONION result */
+    void add_onion_cb(TorControlConnection& conn, const TorControlReply& reply);
+    /** Callback for AUTHENTICATE result */
+    void auth_cb(TorControlConnection& conn, const TorControlReply& reply);
+    /** Callback for AUTHCHALLENGE result */
+    void authchallenge_cb(TorControlConnection& conn, const TorControlReply& reply);
+    /** Callback for PROTOCOLINFO result */
+    void protocolinfo_cb(TorControlConnection& conn, const TorControlReply& reply);
+    /** Callback after succesful connection */
+    void connected_cb(TorControlConnection& conn);
+    /** Callback after connection lost or failed connection attempt */
+    void disconnected_cb(TorControlConnection& conn);
+
+    /** Callback for reconnect timer */
+    static void reconnect_cb(evutil_socket_t fd, short what, void *arg);
+};
+
+TorController::TorController(struct event_base* base, const std::string& target):
+    base(base),
+    target(target), conn(base), reconnect(true), reconnect_ev(0),
+    reconnect_timeout(RECONNECT_TIMEOUT_START)
+{
+    // Start connection attempts immediately
+    if (!conn.Connect(target, boost::bind(&TorController::connected_cb, this, _1),
+         boost::bind(&TorController::disconnected_cb, this, _1) )) {
+        LogPrintf("tor: Initiating connection to Tor control port %s failed\n", target);
+    }
+    // Read service private key if cached
+    std::pair<bool,std::string> pkf = ReadBinaryFile(GetPrivateKeyFile());
+    if (pkf.first) {
+        LogPrint("tor", "tor: Reading cached private key from %s\n", GetPrivateKeyFile());
+        private_key = pkf.second;
+    }
+}
+
+TorController::~TorController()
+{
+    if (reconnect_ev)
+        event_del(reconnect_ev);
+    if (service.IsValid()) {
+        RemoveLocal(service);
+    }
+}
+
+void TorController::add_onion_cb(TorControlConnection& conn, const TorControlReply& reply)
+{
+    if (reply.code == 250) {
+        LogPrint("tor", "tor: ADD_ONION succesful\n");
+        BOOST_FOREACH(const std::string &s, reply.lines) {
+            std::map<std::string,std::string> m = ParseTorReplyMapping(s);
+            std::map<std::string,std::string>::iterator i;
+            if ((i = m.find("ServiceID")) != m.end())
+                service_id = i->second;
+            if ((i = m.find("PrivateKey")) != m.end())
+                private_key = i->second;
+        }
+
+        service = CService(service_id+".onion", GetListenPort(), false);
+        LogPrintf("tor: Got service ID %s, advertizing service %s\n", service_id, service.ToString());
+        if (WriteBinaryFile(GetPrivateKeyFile(), private_key)) {
+            LogPrint("tor", "tor: Cached service private key to %s\n", GetPrivateKeyFile());
+        } else {
+            LogPrintf("tor: Error writing service private key to %s\n", GetPrivateKeyFile());
+        }
+        AddLocal(service, LOCAL_MANUAL);
+        // ... onion requested - keep connection open
+    } else if (reply.code == 510) { // 510 Unrecognized command
+        LogPrintf("tor: Add onion failed with unrecognized command (You probably need to upgrade Tor)\n");
+    } else {
+        LogPrintf("tor: Add onion failed; error code %d\n", reply.code);
+    }
+}
+
+void TorController::auth_cb(TorControlConnection& conn, const TorControlReply& reply)
+{
+    if (reply.code == 250) {
+        LogPrint("tor", "tor: Authentication succesful\n");
+        // Finally - now create the service
+        if (private_key.empty()) // No private key, generate one
+            private_key = "NEW:BEST";
+        // Request hidden service, redirect port.
+        // Note that the 'virtual' port doesn't have to be the same as our internal port, but this is just a convenient
+        // choice.  TODO; refactor the shutdown sequence some day.
+        conn.Command(strprintf("ADD_ONION %s Port=%i,127.0.0.1:%i", private_key, GetListenPort(), GetListenPort()),
+            boost::bind(&TorController::add_onion_cb, this, _1, _2));
+    } else {
+        LogPrintf("tor: Authentication failed\n");
+    }
+}
+
+/** Compute Tor SAFECOOKIE response.
+ *
+ *    ServerHash is computed as:
+ *      HMAC-SHA256("Tor safe cookie authentication server-to-controller hash",
+ *                  CookieString | ClientNonce | ServerNonce)
+ *    (with the HMAC key as its first argument)
+ *
+ *    After a controller sends a successful AUTHCHALLENGE command, the
+ *    next command sent on the connection must be an AUTHENTICATE command,
+ *    and the only authentication string which that AUTHENTICATE command
+ *    will accept is:
+ *
+ *      HMAC-SHA256("Tor safe cookie authentication controller-to-server hash",
+ *                  CookieString | ClientNonce | ServerNonce)
+ *
+ */
+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)
+{
+    CHMAC_SHA256 computeHash((const uint8_t*)key.data(), key.size());
+    std::vector<uint8_t> computedHash(CHMAC_SHA256::OUTPUT_SIZE, 0);
+    computeHash.Write(begin_ptr(cookie), cookie.size());
+    computeHash.Write(begin_ptr(clientNonce), clientNonce.size());
+    computeHash.Write(begin_ptr(serverNonce), serverNonce.size());
+    computeHash.Finalize(begin_ptr(computedHash));
+    return computedHash;
+}
+
+void TorController::authchallenge_cb(TorControlConnection& conn, const TorControlReply& reply)
+{
+    if (reply.code == 250) {
+        LogPrint("tor", "tor: SAFECOOKIE authentication challenge succesful\n");
+        std::pair<std::string,std::string> l = SplitTorReplyLine(reply.lines[0]);
+        if (l.first == "AUTHCHALLENGE") {
+            std::map<std::string,std::string> m = ParseTorReplyMapping(l.second);
+            std::vector<uint8_t> serverHash = ParseHex(m["SERVERHASH"]);
+            std::vector<uint8_t> serverNonce = ParseHex(m["SERVERNONCE"]);
+            LogPrint("tor", "tor: AUTHCHALLENGE ServerHash %s ServerNonce %s\n", HexStr(serverHash), HexStr(serverNonce));
+            if (serverNonce.size() != 32) {
+                LogPrintf("tor: ServerNonce is not 32 bytes, as required by spec\n");
+                return;
+            }
+
+            std::vector<uint8_t> computedServerHash = ComputeResponse(TOR_SAFE_SERVERKEY, cookie, clientNonce, serverNonce);
+            if (computedServerHash != serverHash) {
+                LogPrintf("tor: ServerHash %s does not match expected ServerHash %s\n", HexStr(serverHash), HexStr(computedServerHash));
+                return;
+            }
+
+            std::vector<uint8_t> computedClientHash = ComputeResponse(TOR_SAFE_CLIENTKEY, cookie, clientNonce, serverNonce);
+            conn.Command("AUTHENTICATE " + HexStr(computedClientHash), boost::bind(&TorController::auth_cb, this, _1, _2));
+        } else {
+            LogPrintf("tor: Invalid reply to AUTHCHALLENGE\n");
+        }
+    } else {
+        LogPrintf("tor: SAFECOOKIE authentication challenge failed\n");
+    }
+}
+
+void TorController::protocolinfo_cb(TorControlConnection& conn, const TorControlReply& reply)
+{
+    if (reply.code == 250) {
+        std::set<std::string> methods;
+        std::string cookiefile;
+        /*
+         * 250-AUTH METHODS=COOKIE,SAFECOOKIE COOKIEFILE="/home/x/.tor/control_auth_cookie"
+         * 250-AUTH METHODS=NULL
+         * 250-AUTH METHODS=HASHEDPASSWORD
+         */
+        BOOST_FOREACH(const std::string &s, reply.lines) {
+            std::pair<std::string,std::string> l = SplitTorReplyLine(s);
+            if (l.first == "AUTH") {
+                std::map<std::string,std::string> m = ParseTorReplyMapping(l.second);
+                std::map<std::string,std::string>::iterator i;
+                if ((i = m.find("METHODS")) != m.end())
+                    boost::split(methods, i->second, boost::is_any_of(","));
+                if ((i = m.find("COOKIEFILE")) != m.end())
+                    cookiefile = i->second;
+            } else if (l.first == "VERSION") {
+                std::map<std::string,std::string> m = ParseTorReplyMapping(l.second);
+                std::map<std::string,std::string>::iterator i;
+                if ((i = m.find("Tor")) != m.end()) {
+                    LogPrint("tor", "tor: Connected to Tor version %s\n", i->second);
+                }
+            }
+        }
+        BOOST_FOREACH(const std::string &s, methods) {
+            LogPrint("tor", "tor: Supported authentication method: %s\n", s);
+        }
+        // Prefer NULL, otherwise SAFECOOKIE. If a password is provided, use HASHEDPASSWORD
+        /* Authentication:
+         *   cookie:   hex-encoded ~/.tor/control_auth_cookie
+         *   password: "password"
+         */
+        std::string torpassword = GetArg("-torpassword", "");
+        if (methods.count("NULL")) {
+            LogPrint("tor", "tor: Using NULL authentication\n");
+            conn.Command("AUTHENTICATE", boost::bind(&TorController::auth_cb, this, _1, _2));
+        } else if (methods.count("SAFECOOKIE")) {
+            // Cookie: hexdump -e '32/1 "%02x""\n"'  ~/.tor/control_auth_cookie
+            LogPrint("tor", "tor: Using SAFECOOKIE authentication, reading cookie authentication from %s\n", cookiefile);
+            std::pair<bool,std::string> status_cookie = ReadBinaryFile(cookiefile, TOR_COOKIE_SIZE);
+            if (status_cookie.first && status_cookie.second.size() == TOR_COOKIE_SIZE) {
+                // conn.Command("AUTHENTICATE " + HexStr(status_cookie.second), boost::bind(&TorController::auth_cb, this, _1, _2));
+                cookie = std::vector<uint8_t>(status_cookie.second.begin(), status_cookie.second.end());
+                clientNonce = std::vector<uint8_t>(TOR_NONCE_SIZE, 0);
+                GetRandBytes(&clientNonce[0], TOR_NONCE_SIZE);
+                conn.Command("AUTHCHALLENGE SAFECOOKIE " + HexStr(clientNonce), boost::bind(&TorController::authchallenge_cb, this, _1, _2));
+            } else {
+                if (status_cookie.first) {
+                    LogPrintf("tor: Authentication cookie %s is not exactly %i bytes, as is required by the spec\n", cookiefile, TOR_COOKIE_SIZE);
+                } else {
+                    LogPrintf("tor: Authentication cookie %s could not be opened (check permissions)\n", cookiefile);
+                }
+            }
+        } else if (methods.count("HASHEDPASSWORD")) {
+            if (!torpassword.empty()) {
+                LogPrint("tor", "tor: Using HASHEDPASSWORD authentication\n");
+                boost::replace_all(torpassword, "\"", "\\\"");
+                conn.Command("AUTHENTICATE \"" + torpassword + "\"", boost::bind(&TorController::auth_cb, this, _1, _2));
+            } else {
+                LogPrintf("tor: Password authentication required, but no password provided with -torpassword\n");
+            }
+        } else {
+            LogPrintf("tor: No supported authentication method\n");
+        }
+    } else {
+        LogPrintf("tor: Requesting protocol info failed\n");
+    }
+}
+
+void TorController::connected_cb(TorControlConnection& conn)
+{
+    reconnect_timeout = RECONNECT_TIMEOUT_START;
+    // First send a PROTOCOLINFO command to figure out what authentication is expected
+    if (!conn.Command("PROTOCOLINFO 1", boost::bind(&TorController::protocolinfo_cb, this, _1, _2)))
+        LogPrintf("tor: Error sending initial protocolinfo command\n");
+}
+
+void TorController::disconnected_cb(TorControlConnection& conn)
+{
+    // Stop advertizing service when disconnected
+    if (service.IsValid())
+        RemoveLocal(service);
+    service = CService();
+    if (!reconnect)
+        return;
+    LogPrintf("tor: Disconnected from Tor control port %s, trying to reconnect\n", target);
+    // Single-shot timer for reconnect. Use exponential backoff.
+    struct timeval time = MillisToTimeval(int64_t(reconnect_timeout * 1000.0));
+    reconnect_ev = event_new(base, -1, 0, reconnect_cb, this);
+    event_add(reconnect_ev, &time);
+    reconnect_timeout *= RECONNECT_TIMEOUT_EXP;
+}
+
+void TorController::Reconnect()
+{
+    /* Try to reconnect and reestablish if we get booted - for example, Tor
+     * may be restarting.
+     */
+    if (!conn.Connect(target, boost::bind(&TorController::connected_cb, this, _1),
+         boost::bind(&TorController::disconnected_cb, this, _1) )) {
+        LogPrintf("tor: Re-initiating connection to Tor control port %s failed\n", target);
+    }
+}
+
+std::string TorController::GetPrivateKeyFile()
+{
+    return (GetDataDir() / "onion_private_key").string();
+}
+
+void TorController::reconnect_cb(evutil_socket_t fd, short what, void *arg)
+{
+    TorController *self = (TorController*)arg;
+    self->Reconnect();
+}
+
+/****** Thread ********/
+struct event_base *base;
+boost::thread torControlThread;
+
+static void TorControlThread()
+{
+    TorController ctrl(base, GetArg("-torcontrol", DEFAULT_TOR_CONTROL));
+
+    event_base_dispatch(base);
+}
+
+void StartTorControl(boost::thread_group& threadGroup, CScheduler& scheduler)
+{
+    assert(!base);
+#ifdef WIN32
+    evthread_use_windows_threads();
+#else
+    evthread_use_pthreads();
+#endif
+    base = event_base_new();
+    if (!base) {
+        LogPrintf("tor: Unable to create event_base\n");
+        return;
+    }
+
+    torControlThread = boost::thread(boost::bind(&TraceThread<void (*)()>, "torcontrol", &TorControlThread));
+}
+
+void InterruptTorControl()
+{
+    if (base) {
+        LogPrintf("tor: Thread interrupt\n");
+        event_base_loopbreak(base);
+    }
+}
+
+void StopTorControl()
+{
+    if (base) {
+        torControlThread.join();
+        event_base_free(base);
+        base = 0;
+    }
+}
+

src/torcontrol.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+/**
+ * Functionality for communicating with Tor.
+ */
+#ifndef BITCOIN_TORCONTROL_H
+#define BITCOIN_TORCONTROL_H
+
+#include "scheduler.h"
+
+extern const std::string DEFAULT_TOR_CONTROL;
+static const bool DEFAULT_LISTEN_ONION = true;
+
+void StartTorControl(boost::thread_group& threadGroup, CScheduler& scheduler);
+void InterruptTorControl();
+void StopTorControl();
+
+#endif /* BITCOIN_TORCONTROL_H */