Merge pull request #61 from aarani/exitNode

Support for exit nodes

Author: aarani

NOnion.Tests/OutsideWorldConnectionTest.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+using NUnit.Framework;
+
+using NOnion.Directory;
+using NOnion.Http;
+using NOnion.Network;
+
+namespace NOnion.Tests
+{
+    internal class OutsideWorldConnectionTest
+    {
+        [SetUp]
+        public void Init()
+        {
+            TorLogger.Init(TestContext.Progress.WriteLine);
+        }
+
+        /* It's possible that the router returned by GetRandomFallbackDirectory or
+         * GetRandomRoutersForDirectoryBrowsing be inaccessable so we need to continue
+         * retrying if an exceptions happened to make sure the issues are not related
+         * to the router we randomly chose
+         */
+        private const int TestsRetryCount = 10;
+
+        private async Task BrowseGoogle()
+        {
+            var directory = await TorDirectory.BootstrapAsync(FallbackDirectorySelector.GetRandomFallbackDirectory(), new DirectoryInfo(Path.GetTempPath()));
+            var (guardEndPoint, guardRouter) = await directory.GetRouterAsync(RouterType.Guard);
+            var (_, middleRouter) = await directory.GetRouterAsync(RouterType.Normal);
+            var (_, exitRouter) = await directory.GetRouterAsync(RouterType.Exit);
+
+            var guard = await TorGuard.NewClientAsync(guardEndPoint);
+            var circuit = new TorCircuit(guard);
+            await circuit.CreateAsync(guardRouter);
+            await circuit.ExtendAsync(middleRouter);
+            await circuit.ExtendAsync(exitRouter);
+
+            TorStream stream = new TorStream(circuit);
+            await stream.ConnectToOutsideAsync("google.com", 80);
+
+            TorHttpClient httpClient = new TorHttpClient(stream, "google.com");
+            await httpClient.GetAsStringAsync("/", false);
+        }
+
+        [Test]
+        [Retry(TestsRetryCount)]
+        public void CanBrowseGoogle()
+        {
+            Assert.ThrowsAsync(typeof(UnsuccessfulHttpRequestException), BrowseGoogle);
+        }
+    }
+}

NOnion/Directory/TorDirectory.fs

@@ -17,6 +17,7 @@ type RouterType =
     | Normal
     | Guard
     | Directory
+    | Exit
 
 type TorDirectory =
     private
@@ -174,6 +175,9 @@ type TorDirectory =
                        Seq.filter(fun router ->
                            Seq.contains "Guard" router.Flags
                        )
+                   | Exit ->
+                       Seq.filter(fun router -> Seq.contains "Exit" router.Flags
+                       )
                 |> SeqUtils.TakeRandom 1
                 |> Seq.tryHead
 

NOnion/Network/TorStream.fs

@@ -28,8 +28,8 @@ type private StreamControlMessage =
         offset: int *
         length: int *
         replyChannel: AsyncReplyChannel<OperationResult<unit>>
-    | StartServiceConnectionProcess of
-        port: int *
+    | StartStreamConnectionProcess of
+        address: string *
         streamObj: ITorStream *
         replyChannel: AsyncReplyChannel<OperationResult<Task<uint16>>>
     | StartDirectoryConnectionProcess of
@@ -120,7 +120,10 @@ type TorStream(circuit: TorCircuit) =
                         "Unexpected state when trying to send data over stream"
             }
 
-        let startServiceConnectionProcess (port: int) (streamObj: ITorStream) =
+        let startStreamConnectionProcess
+            (address: string)
+            (streamObj: ITorStream)
+            =
             async {
                 let streamId = circuit.RegisterStream streamObj None
 
@@ -139,7 +142,7 @@ type TorStream(circuit: TorCircuit) =
                         streamId
                         (RelayBegin
                             {
-                                RelayBegin.Address = (sprintf ":%i" port)
+                                RelayBegin.Address = address
                                 Flags = 0u
                             })
                         None
@@ -236,9 +239,9 @@ type TorStream(circuit: TorCircuit) =
                 do!
                     safeSend data offset length
                     |> TryExecuteAsyncAndReplyAsResult replyChannel
-            | StartServiceConnectionProcess(port, streamObj, replyChannel) ->
+            | StartStreamConnectionProcess(address, streamObj, replyChannel) ->
                 do!
-                    startServiceConnectionProcess port streamObj
+                    startStreamConnectionProcess address streamObj
                     |> TryExecuteAsyncAndReplyAsResult replyChannel
             | StartDirectoryConnectionProcess(streamObj, replyChannel) ->
                 do!
@@ -463,8 +466,8 @@ type TorStream(circuit: TorCircuit) =
             let! completionTaskRes =
                 streamControlMailBox.PostAndAsyncReply(
                     (fun replyChannel ->
-                        StreamControlMessage.StartServiceConnectionProcess(
-                            port,
+                        StreamControlMessage.StartStreamConnectionProcess(
+                            sprintf ":%i" port,
                             self,
                             replyChannel
                         )
@@ -502,6 +505,30 @@ type TorStream(circuit: TorCircuit) =
     member self.ConnectToDirectoryAsync() =
         self.ConnectToDirectory() |> Async.StartAsTask
 
+    member self.ConnectToOutside (address: string) (port: int) =
+        async {
+            let! completionTaskRes =
+                streamControlMailBox.PostAndAsyncReply(
+                    (fun replyChannel ->
+                        StreamControlMessage.StartStreamConnectionProcess(
+                            sprintf "%s:%i" address port,
+                            self,
+                            replyChannel
+                        )
+                    ),
+                    Constants.StreamCreationTimeout.TotalMilliseconds |> int
+                )
+
+            return!
+                completionTaskRes
+                |> UnwrapResult
+                |> Async.AwaitTask
+                |> FSharpUtil.WithTimeout Constants.StreamCreationTimeout
+        }
+
+    member self.ConnectToOutsideAsync(address, port) =
+        self.ConnectToOutside address port |> Async.StartAsTask
+
     member private self.RegisterIncomingStream(streamId: uint16) =
         async {
             let! registerationResult =