private async Task CanChangeCircuitAsync()
{
var requestUri = "https://api.ipify.org/";
IPAddress torIp;
IPAddress changedIp;
// 1. Get Tor IP
var handler = new TorSocks5Handler(SharedFixture.TorSock5EndPoint);
using (var httpClient = new HttpClient(handler))
{
var content = await(await httpClient.GetAsync(requestUri)).Content.ReadAsStringAsync();
var gotIp = IPAddress.TryParse(content.Replace("\n", ""), out torIp);
Assert.True(gotIp);
}
// 2. Change Tor IP
var controlPortClient = new TorControlClient(SharedFixture.HostAddress, SharedFixture.ControlPort, SharedFixture.ControlPortPassword);
await controlPortClient.ChangeCircuitAsync();
// 3. Get changed Tor IP
var handler2 = new TorSocks5Handler(SharedFixture.TorSock5EndPoint);
using (var httpClient = new HttpClient(handler2))
{
var content = await(await httpClient.GetAsync(requestUri)).Content.ReadAsStringAsync();
var gotIp = IPAddress.TryParse(content.Replace("\n", ""), out changedIp);
Assert.True(gotIp);
}
Assert.NotEqual(changedIp, torIp);
}
/// <summary>Connects to Tor control using a TCP client or throws <see cref="TorControlException"/>.</summary>
/// <exception cref="TorControlException">When authentication fails for some reason.</exception>
/// <seealso href="https://gitweb.torproject.org/torspec.git/tree/control-spec.txt">This method follows instructions in 3.23. TAKEOWNERSHIP.</seealso>
private async Task <TorControlClient> InitTorControlAsync(CancellationToken token = default)
{
// Get cookie.
string cookieString = ByteHelpers.ToHex(File.ReadAllBytes(Settings.CookieAuthFilePath));
// Authenticate.
TorControlClientFactory factory = new();
TorControlClient client = await factory.ConnectAndAuthenticateAsync(Settings.ControlEndpoint, cookieString, token).ConfigureAwait(false);
if (Settings.TerminateOnExit)
{
// This is necessary for the scenario when Tor was started by a previous WW instance with TerminateTorOnExit=false configuration option.
TorControlReply takeReply = await client.TakeOwnershipAsync(token).ConfigureAwait(false);
if (!takeReply)
{
throw new TorControlException($"Failed to take ownership of the Tor instance. Reply: '{takeReply}'.");
}
TorControlReply resetReply = await client.ResetOwningControllerProcessConfAsync(token).ConfigureAwait(false);
if (!resetReply)
{
throw new TorControlException($"Failed to reset __OwningControllerProcess. Reply: '{resetReply}'.");
}
}
return(client);
}
private async Task IsCircuitEstablishedAsync()
{
var controlPortClient = new TorControlClient(SharedFixture.HostAddress, SharedFixture.ControlPort, SharedFixture.ControlPortPassword);
var yes = await controlPortClient.IsCircuitEstablishedAsync();
Assert.True(yes);
}
private static async Task RequestWith3IpAsync()
{
var requestUri = "https://api.ipify.org/";
// 1. Get real IP
using (var httpClient = new HttpClient())
{
var message = await httpClient.GetAsync(requestUri);
var content = await message.Content.ReadAsStringAsync();
Logger.LogInfo($"Your real IP: \t\t{content}");
}
// 2. Get Tor IP
using (var httpClient = new HttpClient(new TorSocks5Handler(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050))))
{
var message = await httpClient.GetAsync(requestUri);
var content = await message.Content.ReadAsStringAsync();
Logger.LogInfo($"Your Tor IP: \t\t{content}");
// 3. Change Tor IP
var controlPortClient = new TorControlClient("127.0.0.1", controlPort: 9051, password: "******");
await controlPortClient.ChangeCircuitAsync();
// 4. Get changed Tor IP
message = await httpClient.GetAsync(requestUri);
content = await message.Content.ReadAsStringAsync();
Logger.LogInfo($"Your other Tor IP: \t{content}");
}
}
private async Task CanSendCustomCommandAsync()
{
var controlPortClient = new TorControlClient(SharedFixture.HostAddress, SharedFixture.ControlPort, SharedFixture.ControlPortPassword);
var res = await controlPortClient.SendCommandAsync("GETCONF SOCKSPORT");
res = res.Replace('-', ' ');
Assert.StartsWith("250 SocksPort", res);
}
/// <summary>
/// Returns a connected and authenticated a Tor control client for the running Tor process. The caller is
/// responsible for disposing of the returned control client.
/// </summary>
/// <returns>The Tor control client that is already connected and authenticated.</returns>
public async Task <TorControlClient> GetControlClientAsync()
{
var client = new TorControlClient();
await client.ConnectAsync(TorHostName, _settings.TorSettings.ControlPort).ConfigureAwait(false);
await client.AuthenticateAsync(_settings.TorSettings.ControlPassword).ConfigureAwait(false);
return(client);
}
public async Task <string> GetCircuitStatusAsync()
{
using (var client = new TorControlClient())
{
await client.ConnectAsync("localhost", _settings.TorControlPort).ConfigureAwait(false);
await client.AuthenticateAsync(_settings.TorControlPassword).ConfigureAwait(false);
return(await client.GetInfoAsync("circuit-status"));
}
}
public async Task GetNewIdentityAsync()
{
using (var client = new TorControlClient())
{
await client.ConnectAsync("localhost", _settings.TorControlPort).ConfigureAwait(false);
await client.AuthenticateAsync(_settings.TorControlPassword).ConfigureAwait(false);
await client.CleanCircuitsAsync();
}
}
public async Task <string> CloseCircuitAsync(string circuitId)
{
using (var client = new TorControlClient())
{
await client.ConnectAsync("localhost", _settings.TorControlPort).ConfigureAwait(false);
await client.AuthenticateAsync(_settings.TorControlPassword).ConfigureAwait(false);
return(await client.CloseCircuitAsync(circuitId));
}
}
public async Task <string> GetNetworkStatusForORAsync(string orName)
{
using (var client = new TorControlClient())
{
await client.ConnectAsync("localhost", _settings.TorControlPort).ConfigureAwait(false);
await client.AuthenticateAsync(_settings.TorControlPassword).ConfigureAwait(false);
return(await client.GetInfoAsync($"ns/name/{orName}"));
}
}
public async Task SafeCookieAuthenticationAsync()
{
using CancellationTokenSource timeoutCts = new(TimeSpan.FromMinutes(2));
// Setup.
string cookieString = "200339DD9897265DF859C6578DFB51E2E867AA8966C9112349262F5398DEFC3D";
string clientNonce = "6F14C18D5B00BF54E16E4728A4BFC81B1FF469F0B012CD71D9724BFBE14DB5E6";
string serverHash = "E3C00FB4A14AF48B43CE8A13E4BB01F8C72796352072B1994EE21D35148931C1";
string serverNonce = "1650507A46A2979974DA72A833523B72789A65F6E24EAA59C5DF1D3DC294228D";
Mock <IRandom> mockRandom = new(MockBehavior.Strict);
mockRandom.Setup(c => c.GetBytes(It.IsAny <byte[]>()))
.Callback((byte[] dest) => Array.Copy(sourceArray: ByteHelpers.FromHex(clientNonce), dest, 32));
TorControlClientFactory clientFactory = new(mockRandom.Object);
Pipe toServer = new();
Pipe toClient = new();
await using TorControlClient testClient = new(pipeReader : toClient.Reader, pipeWriter : toServer.Writer);
Logger.LogTrace("Client: Start authentication task.");
Task <TorControlClient> authenticationTask = clientFactory.AuthSafeCookieOrThrowAsync(testClient, cookieString, timeoutCts.Token);
Logger.LogTrace("Server: Read 'AUTHCHALLENGE SAFECOOKIE' command from the client.");
string authChallengeCommand = await toServer.Reader.ReadLineAsync(timeoutCts.Token);
Logger.LogTrace($"Server: Received AUTHCHALLENGE line: '{authChallengeCommand}'.");
Assert.Equal("AUTHCHALLENGE SAFECOOKIE 6F14C18D5B00BF54E16E4728A4BFC81B1FF469F0B012CD71D9724BFBE14DB5E6", authChallengeCommand);
Logger.LogTrace("Server: Respond to client's AUTHCHALLENGE request.");
string challengeResponse = $"250 AUTHCHALLENGE SERVERHASH={serverHash} SERVERNONCE={serverNonce}\r\n";
await toClient.Writer.WriteAsciiAndFlushAsync(challengeResponse, timeoutCts.Token);
Logger.LogTrace("Server: Read 'AUTHENTICATE' command from the client.");
string authCommand = await toServer.Reader.ReadLineAsync(timeoutCts.Token);
Logger.LogTrace($"Server: Received auth line: '{authCommand}'.");
Assert.Equal("AUTHENTICATE 6013EA09D4E36B6CF01C18A707D350C1B5AFF8C1A21527266B9FC40C89BDCB4A", authCommand);
Logger.LogTrace("Server: Respond to the client's AUTHENTICATION request.");
await toClient.Writer.WriteAsciiAndFlushAsync("250 OK\r\n", timeoutCts.Token);
Logger.LogTrace("Client: Verify the authentication task finishes correctly.");
TorControlClient authenticatedClient = await authenticationTask;
Assert.NotNull(authenticatedClient);
}
public SharedFixture()
{
// Initialize tests...
Logger.SetMinimumLevel(LogLevel.Debug);
Logger.SetModes(LogMode.Debug, LogMode.File);
Logger.SetFilePath("TestLogs.txt");
HostAddress = "127.0.0.1";
SocksPort = 9050;
ControlPort = 9051;
ControlPortPassword = "******";
TorProcess = null;
var torControl = new TorControlClient(HostAddress, ControlPort, ControlPortPassword);
try
{
torControl.IsCircuitEstablishedAsync().GetAwaiter().GetResult();
}
catch
{
var torProcessStartInfo = new ProcessStartInfo("tor")
{
Arguments = $"SOCKSPort {SocksPort} ControlPort {ControlPort} HashedControlPassword 16:0978DBAF70EEB5C46063F3F6FD8CBC7A86DF70D2206916C1E2AE29EAF6",
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true
};
TorProcess = Process.Start(torProcessStartInfo);
Task.Delay(3000).GetAwaiter().GetResult();
var established = false;
var count = 0;
while (!established)
{
if (count >= 21)
{
throw new TorException("Couldn't establish circuit in time.");
}
established = torControl.IsCircuitEstablishedAsync().GetAwaiter().GetResult();
Task.Delay(1000).GetAwaiter().GetResult();
count++;
}
}
}
public async Task CanDisposeAfterFailedConnect()
{
TorControlClient client = null;
try
{
client = new TorControlClient();
await client.ConnectAsync("300.0.0.0", 12345);
}
catch
{
}
finally
{
client.Dispose();
}
}
private async Task CanChangeCircuitMultipleTimesAsync()
{
var requestUri = "https://api.ipify.org/";
// 1. Get Tor IP
IPAddress currIp = await GetTorIpAsync(requestUri);
var controlPortClient = new TorControlClient(SharedFixture.HostAddress, SharedFixture.ControlPort, SharedFixture.ControlPortPassword);
for (int i = 0; i < 3; i++)
{
IPAddress prevIp = currIp;
// Change Tor IP
await controlPortClient.ChangeCircuitAsync();
// Get changed Tor IP
currIp = await GetTorIpAsync(requestUri);
Assert.NotEqual(prevIp, currIp);
}
}
public void RefreshIp()
{
var controlPortClient = new TorControlClient("127.0.0.1", controlPort: 9051, password: "******");
controlPortClient.ChangeCircuitAsync().Wait();
}
