Support for Tor onion services

eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala

@@ -62,7 +62,9 @@ class Setup(datadir: File,
   logger.info(s"hello!")
   logger.info(s"version=${getClass.getPackage.getImplementationVersion} commit=${getClass.getPackage.getSpecificationVersion}")
   logger.info(s"datadir=${datadir.getCanonicalPath}")
-
+  logger.info(s"initializing secure random generator")
+  // this will force the secure random instance to initialize itself right now, making sure it doesn't hang later (see comment in package.scala)
+  secureRandom.nextInt()
 
   val config = NodeParams.loadConfiguration(datadir, overrideDefaults)
   val seed = seed_opt.getOrElse(NodeParams.getSeed(datadir))
@@ -73,12 +75,11 @@ class Setup(datadir: File,
   implicit val formats = org.json4s.DefaultFormats
   implicit val ec = ExecutionContext.Implicits.global
 
-  logger.info(s"initializing secure random generator")
-  // this will force the secure random instance to initialize itself right now, making sure it doesn't hang later (see comment in package.scala)
-  secureRandom.nextInt()
-
   val nodeParams = NodeParams.makeNodeParams(datadir, config, keyManager, initTor())
 
+  logger.info(s"nodeid=${nodeParams.nodeId} alias=${nodeParams.alias}")
+  logger.info(s"using chain=$chain chainHash=${nodeParams.chainHash}")
+
   // always bind the server to localhost when using Tor
   val serverBindingAddress = new InetSocketAddress(
     if (config.getBoolean("tor.enabled")) "127.0.0.1" else config.getString("server.binding-ip"),
@@ -89,9 +90,6 @@ class Setup(datadir: File,
   DBCompatChecker.checkNetworkDBCompatibility(nodeParams)
   PortChecker.checkAvailable(serverBindingAddress)
 
-  logger.info(s"nodeid=${nodeParams.nodeId} alias=${nodeParams.alias}")
-  logger.info(s"using chain=$chain chainHash=${nodeParams.chainHash}")
-
   val bitcoin = nodeParams.watcherType match {
     case BITCOIND =>
       val bitcoinClient = new BasicBitcoinJsonRPCClient(
@@ -201,7 +199,8 @@ class Setup(datadir: File,
       relayer = system.actorOf(SimpleSupervisor.props(Relayer.props(nodeParams, register, paymentHandler), "relayer", SupervisorStrategy.Resume))
       router = system.actorOf(SimpleSupervisor.props(Router.props(nodeParams, watcher), "router", SupervisorStrategy.Resume))
       authenticator = system.actorOf(SimpleSupervisor.props(Authenticator.props(nodeParams), "authenticator", SupervisorStrategy.Resume))
-      switchboard = system.actorOf(SimpleSupervisor.props(Switchboard.props(nodeParams, authenticator, watcher, router, relayer, wallet), "switchboard", SupervisorStrategy.Resume))
+      socksProxy = if (config.getBoolean("tor.enabled")) Some(new InetSocketAddress(config.getString("tor.host"), config.getInt("tor.socks-port"))) else None
+      switchboard = system.actorOf(SimpleSupervisor.props(Switchboard.props(nodeParams, authenticator, watcher, router, relayer, wallet, socksProxy), "switchboard", SupervisorStrategy.Resume))
       server = system.actorOf(SimpleSupervisor.props(Server.props(nodeParams, authenticator, serverBindingAddress, Some(tcpBound)), "server", SupervisorStrategy.Restart))
       paymentInitiator = system.actorOf(SimpleSupervisor.props(PaymentInitiator.props(nodeParams.nodeId, router, register), "payment-initiator", SupervisorStrategy.Restart))
 
@@ -267,8 +266,6 @@ class Setup(datadir: File,
 
   private def initTor(): Option[InetSocketAddress] = {
     if (config.getBoolean("tor.enabled")) {
-      sys.props.put("socksProxyHost", config.getString("tor.host"))
-      sys.props.put("socksProxyPort", config.getInt("tor.socks-port").toString)
       if (config.getString("tor.protocol") != "socks") {
         val promiseTorAddress = Promise[OnionAddress]()
         val protocolHandler = system.actorOf(TorProtocolHandler.props(

eclair-core/src/main/scala/fr/acinq/eclair/io/Client.scala

@@ -23,39 +23,77 @@ import akka.event.Logging.MDC
 import akka.io.Tcp.SO.KeepAlive
 import akka.io.{IO, Tcp}
 import fr.acinq.bitcoin.Crypto.PublicKey
-import fr.acinq.eclair.{Logs, NodeParams}
 import fr.acinq.eclair.io.Client.ConnectionFailed
+import fr.acinq.eclair.tor.Socks5Connection
+import fr.acinq.eclair.tor.Socks5Connection.{Socks5Connect, Socks5Connected}
+import fr.acinq.eclair.{Logs, NodeParams}
 
 import scala.concurrent.duration._
 
 /**
   * Created by PM on 27/10/2015.
   *
   */
-class Client(nodeParams: NodeParams, authenticator: ActorRef, address: InetSocketAddress, remoteNodeId: PublicKey, origin_opt: Option[ActorRef]) extends Actor with DiagnosticActorLogging {
+class Client(nodeParams: NodeParams, authenticator: ActorRef, address: InetSocketAddress, remoteNodeId: PublicKey, origin_opt: Option[ActorRef], socksProxy: Option[InetSocketAddress]) extends Actor with DiagnosticActorLogging {
 
   import Tcp._
   import context.system
 
   // we could connect directly here but this allows to take advantage of the automated mdc configuration on message reception
   self ! 'connect
 
+  private var connection: ActorRef = _
+
   def receive = {
+
     case 'connect =>
-      log.info(s"connecting to pubkey=$remoteNodeId host=${address.getHostString} port=${address.getPort}")
-      IO(Tcp) ! Connect(address, timeout = Some(5 seconds), options = KeepAlive(true) :: Nil, pullMode = true)
+      val addressToConnect = socksProxy match {
+        case None =>
+          log.info(s"connecting to pubkey=$remoteNodeId host=${address.getHostString} port=${address.getPort}")
+          address
+        case Some(socksProxyAddress) =>
+          log.info(s"connecting to SOCKS5 proxy $socksProxyAddress")
+          socksProxyAddress
+      }
+      IO(Tcp) ! Connect(addressToConnect, timeout = Some(50 seconds), options = KeepAlive(true) :: Nil, pullMode = true)
 
     case CommandFailed(_: Connect) =>
-      log.info(s"connection failed to $remoteNodeId@${address.getHostString}:${address.getPort}")
+      socksProxy match {
+        case None =>
+          log.info(s"connection failed to $remoteNodeId@${address.getHostString}:${address.getPort}")
+        case Some(socksProxyAddress) =>
+          log.info(s"connection failed to SOCKS5 proxy $socksProxyAddress")
+      }
+      origin_opt.map(_ ! Status.Failure(ConnectionFailed(address)))
+      context stop self
+
+    case CommandFailed(_: Socks5Connect) =>
+      log.info(s"connection failed to $remoteNodeId@${address.getHostString}:${address.getPort} via SOCKS5 ${socksProxy.map(_.toString).getOrElse("")}")
       origin_opt.map(_ ! Status.Failure(ConnectionFailed(address)))
       context stop self
 
     case Connected(remote, _) =>
-      log.info(s"connected to pubkey=$remoteNodeId host=${remote.getHostString} port=${remote.getPort}")
-      val connection = sender
-      authenticator ! Authenticator.PendingAuth(connection, remoteNodeId_opt = Some(remoteNodeId), address = address, origin_opt = origin_opt)
-      context watch connection
-      context become connected(connection)
+      socksProxy match {
+        case None =>
+          connection = sender()
+          context watch connection
+          log.info(s"connected to pubkey=$remoteNodeId host=${remote.getHostString} port=${remote.getPort}")
+          authenticator ! Authenticator.PendingAuth(connection, remoteNodeId_opt = Some(remoteNodeId), address = address, origin_opt = origin_opt)
+          context become connected(connection)
+        case Some(_) =>
+          connection = context.actorOf(Socks5Connection.props(sender()))
+          context watch connection
+          connection ! Socks5Connect(address)
+      }
+
+    case Socks5Connected(_) =>
+      socksProxy match {
+        case Some(proxyAddress) =>
+          log.info(s"connected to pubkey=$remoteNodeId host=${address.getHostString} port=${address.getPort} via SOCKS5 proxy $proxyAddress")
+          authenticator ! Authenticator.PendingAuth(connection, remoteNodeId_opt = Some(remoteNodeId), address = address, origin_opt = origin_opt)
+          context become connected(connection)
+        case _ =>
+      }
   }
 
   def connected(connection: ActorRef): Receive = {
@@ -70,7 +108,7 @@ class Client(nodeParams: NodeParams, authenticator: ActorRef, address: InetSocke
 
 object Client extends App {
 
-  def props(nodeParams: NodeParams, authenticator: ActorRef, address: InetSocketAddress, remoteNodeId: PublicKey, origin_opt: Option[ActorRef]): Props = Props(new Client(nodeParams, authenticator, address, remoteNodeId, origin_opt))
+  def props(nodeParams: NodeParams, authenticator: ActorRef, address: InetSocketAddress, remoteNodeId: PublicKey, origin_opt: Option[ActorRef], socksProxy: Option[InetSocketAddress]): Props = Props(new Client(nodeParams, authenticator, address, remoteNodeId, origin_opt, socksProxy))
 
   case class ConnectionFailed(address: InetSocketAddress) extends RuntimeException(s"connection failed to $address")
 

eclair-core/src/main/scala/fr/acinq/eclair/io/Peer.scala

@@ -38,7 +38,7 @@ import scala.util.Random
 /**
   * Created by PM on 26/08/2016.
   */
-class Peer(nodeParams: NodeParams, remoteNodeId: PublicKey, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet) extends FSMDiagnosticActorLogging[Peer.State, Peer.Data] {
+class Peer(nodeParams: NodeParams, remoteNodeId: PublicKey, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet, socksProxy: Option[InetSocketAddress]) extends FSMDiagnosticActorLogging[Peer.State, Peer.Data] {
 
   import Peer._
 
@@ -57,15 +57,15 @@ class Peer(nodeParams: NodeParams, remoteNodeId: PublicKey, authenticator: Actor
   when(DISCONNECTED) {
     case Event(Peer.Connect(NodeURI(_, address)), _) =>
       // even if we are in a reconnection loop, we immediately process explicit connection requests
-      context.actorOf(Client.props(nodeParams, authenticator, new InetSocketAddress(address.getHost, address.getPort), remoteNodeId, origin_opt = Some(sender())))
+      context.actorOf(Client.props(nodeParams, authenticator, new InetSocketAddress(address.getHost, address.getPort), remoteNodeId, origin_opt = Some(sender()), socksProxy))
       stay
 
     case Event(Reconnect, d@DisconnectedData(address_opt, channels, attempts)) =>
       address_opt match {
         case None => stay // no-op (this peer didn't initiate the connection and doesn't have the ip of the counterparty)
         case _ if channels.isEmpty => stay // no-op (no more channels with this peer)
         case Some(address) =>
-          context.actorOf(Client.props(nodeParams, authenticator, address, remoteNodeId, origin_opt = None))
+          context.actorOf(Client.props(nodeParams, authenticator, address, remoteNodeId, origin_opt = None, socksProxy))
           // exponential backoff retry with a finite max
           setTimer(RECONNECT_TIMER, Reconnect, Math.min(10 + Math.pow(2, attempts), 60) seconds, repeat = false)
           stay using d.copy(attempts = attempts + 1)
@@ -431,7 +431,7 @@ object Peer {
 
   val IGNORE_NETWORK_ANNOUNCEMENTS_PERIOD = 5 minutes
 
-  def props(nodeParams: NodeParams, remoteNodeId: PublicKey, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet) = Props(new Peer(nodeParams, remoteNodeId, authenticator, watcher, router, relayer, wallet: EclairWallet))
+  def props(nodeParams: NodeParams, remoteNodeId: PublicKey, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet, socksProxy: Option[InetSocketAddress]) = Props(new Peer(nodeParams, remoteNodeId, authenticator, watcher, router, relayer, wallet, socksProxy))
 
   // @formatter:off
 

eclair-core/src/main/scala/fr/acinq/eclair/io/Switchboard.scala

@@ -16,7 +16,7 @@
 
 package fr.acinq.eclair.io
 
-import java.net.InetSocketAddress
+import java.net.{InetAddress, InetSocketAddress}
 
 import akka.actor.{Actor, ActorLogging, ActorRef, OneForOneStrategy, Props, Status, SupervisorStrategy, Terminated}
 import fr.acinq.bitcoin.Crypto.PublicKey
@@ -29,7 +29,7 @@ import fr.acinq.eclair.router.Rebroadcast
   * Ties network connections to peers.
   * Created by PM on 14/02/2017.
   */
-class Switchboard(nodeParams: NodeParams, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet) extends Actor with ActorLogging {
+class Switchboard(nodeParams: NodeParams, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet, socksProxy: Option[InetSocketAddress]) extends Actor with ActorLogging {
 
   authenticator ! self
 
@@ -101,7 +101,7 @@ class Switchboard(nodeParams: NodeParams, authenticator: ActorRef, watcher: Acto
       case Some(peer) => peer
       case None =>
         log.info(s"creating new peer current=${peers.size}")
-        val peer = context.actorOf(Peer.props(nodeParams, remoteNodeId, authenticator, watcher, router, relayer, wallet), name = s"peer-$remoteNodeId")
+        val peer = context.actorOf(Peer.props(nodeParams, remoteNodeId, authenticator, watcher, router, relayer, wallet, socksProxy), name = s"peer-$remoteNodeId")
         peer ! Peer.Init(previousKnownAddress, offlineChannels)
         context watch (peer)
         peer
@@ -116,6 +116,6 @@ class Switchboard(nodeParams: NodeParams, authenticator: ActorRef, watcher: Acto
 
 object Switchboard {
 
-  def props(nodeParams: NodeParams, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet) = Props(new Switchboard(nodeParams, authenticator, watcher, router, relayer, wallet))
+  def props(nodeParams: NodeParams, authenticator: ActorRef, watcher: ActorRef, router: ActorRef, relayer: ActorRef, wallet: EclairWallet, socksProxy: Option[InetSocketAddress]) = Props(new Switchboard(nodeParams, authenticator, watcher, router, relayer, wallet, socksProxy))
 
 }

eclair-core/src/main/scala/fr/acinq/eclair/tor/Controller.scala

@@ -2,7 +2,7 @@ package fr.acinq.eclair.tor
 
 import java.net.InetSocketAddress
 
-import akka.actor.{Actor, ActorLogging, ActorRef, Props}
+import akka.actor.{Actor, ActorLogging, ActorRef, Props, Terminated}
 import akka.io.{IO, Tcp}
 import akka.util.ByteString
 
@@ -29,6 +29,7 @@ class Controller(address: InetSocketAddress, listener: ActorRef)
       listener ! c
       val connection = sender()
       connection ! Register(self)
+      context watch connection
       context become {
         case data: ByteString =>
           connection ! Write(data)
@@ -41,6 +42,9 @@ class Controller(address: InetSocketAddress, listener: ActorRef)
         case _: ConnectionClosed =>
           context stop listener
           context stop self
+        case Terminated(actor) if actor == connection =>
+          context stop listener
+          context stop self
       }
   }