/// <summary>
/// Extends BeginAuthenticateAsClient so that when a state object is not needed, null does not need to be passed.
/// <example>
/// negotiatestream.BeginAuthenticateAsClient(credential, binding, targetName, requiredProtectionLevel, allowedImpersonationLevel, asyncCallback);
/// </example>
/// </summary>
public static IAsyncResult BeginAuthenticateAsClient(this NegotiateStream negotiatestream, System.Net.NetworkCredential credential, System.Security.Authentication.ExtendedProtection.ChannelBinding binding, String targetName, ProtectionLevel requiredProtectionLevel, System.Security.Principal.TokenImpersonationLevel allowedImpersonationLevel, AsyncCallback asyncCallback)
{
if (negotiatestream == null)
{
throw new ArgumentNullException("negotiatestream");
}
return(negotiatestream.BeginAuthenticateAsClient(credential, binding, targetName, requiredProtectionLevel, allowedImpersonationLevel, asyncCallback, null));
}
/// <summary>
/// Extends BeginAuthenticateAsClient so that when a state object is not needed, null does not need to be passed.
/// <example>
/// negotiatestream.BeginAuthenticateAsClient(credential, targetName, asyncCallback);
/// </example>
/// </summary>
public static IAsyncResult BeginAuthenticateAsClient(this NegotiateStream negotiatestream, System.Net.NetworkCredential credential, String targetName, AsyncCallback asyncCallback)
{
if (negotiatestream == null)
{
throw new ArgumentNullException("negotiatestream");
}
return(negotiatestream.BeginAuthenticateAsClient(credential, targetName, asyncCallback, null));
}
/// <summary>
/// Extends BeginAuthenticateAsClient so that when a state object is not needed, null does not need to be passed.
/// <example>
/// negotiatestream.BeginAuthenticateAsClient(asyncCallback);
/// </example>
/// </summary>
public static IAsyncResult BeginAuthenticateAsClient(this NegotiateStream negotiatestream, AsyncCallback asyncCallback)
{
if (negotiatestream == null)
{
throw new ArgumentNullException("negotiatestream");
}
return(negotiatestream.BeginAuthenticateAsClient(asyncCallback, null));
}
public static void Main(String[] args)
{
//<snippet2>
//<snippet1>
// Establish the remote endpoint for the socket.
// For this example, use the local machine.
IPHostEntry ipHostInfo = Dns.GetHostEntry("localhost");
IPAddress ipAddress = ipHostInfo.AddressList[0];
// Client and server use port 11000.
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);
// Create a TCP/IP socket.
client = new TcpClient();
// Connect the socket to the remote endpoint.
client.Connect(remoteEP);
Console.WriteLine("Client connected to {0}.", remoteEP.ToString());
// Ensure the client does not close when there is
// still data to be sent to the server.
client.LingerState = (new LingerOption(true, 0));
//<snippet3>
// Request authentication.
NetworkStream clientStream = client.GetStream();
NegotiateStream authStream = new NegotiateStream(clientStream, false);
//</snippet1>
// Pass the NegotiateStream as the AsyncState object
// so that it is available to the callback delegate.
IAsyncResult ar = authStream.BeginAuthenticateAsClient(
new AsyncCallback(EndAuthenticateCallback),
authStream
);
//</snippet2>
Console.WriteLine("Client waiting for authentication...");
// Wait until the result is available.
ar.AsyncWaitHandle.WaitOne();
// Display the properties of the authenticated stream.
AuthenticatedStreamReporter.DisplayProperties(authStream);
// Send a message to the server.
// Encode the test data into a byte array.
byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
ar = authStream.BeginWrite(message, 0, message.Length,
new AsyncCallback(EndWriteCallback),
authStream);
//</snippet3>
ar.AsyncWaitHandle.WaitOne();
Console.WriteLine("Sent {0} bytes.", message.Length);
// Close the client connection.
authStream.Close();
Console.WriteLine("Client closed.");
}
protected override Task AuthenticateAsClientAsync(NegotiateStream client, NetworkCredential credential, string targetName) =>
Task.Factory.FromAsync(
(callback, state) => client.BeginAuthenticateAsClient(credential, targetName, ProtectionLevel.EncryptAndSign, TokenImpersonationLevel.Identification, callback, state),
client.EndAuthenticateAsClient, null);
internal static bool TryOpenChannel(NetworkPath netPath, int timeoutInMs, out TcpClientChannel channel, out NetworkTransportException networkEx)
{
channel = null;
networkEx = null;
Exception ex = null;
Socket socket = null;
Stream stream = null;
NegotiateStream negotiateStream = null;
ReplayStopwatch replayStopwatch = new ReplayStopwatch();
replayStopwatch.Start();
try
{
socket = new Socket(netPath.TargetEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
if (netPath.Purpose == NetworkPath.ConnectionPurpose.Seeding)
{
socket.ReceiveBufferSize = RegistryParameters.SeedingNetworkTransferSize;
socket.SendBufferSize = RegistryParameters.SeedingNetworkTransferSize;
}
else
{
socket.ReceiveBufferSize = RegistryParameters.LogCopyNetworkTransferSize;
socket.SendBufferSize = RegistryParameters.LogCopyNetworkTransferSize;
}
if (netPath.HasSourceEndpoint())
{
socket.Bind(netPath.SourceEndPoint);
}
TcpClientChannel.ConnectAbandon connectAbandon = new TcpClientChannel.ConnectAbandon(socket);
IAsyncResult asyncResult = socket.BeginConnect(netPath.TargetEndPoint.Address, netPath.TargetEndPoint.Port, null, connectAbandon);
if (!asyncResult.AsyncWaitHandle.WaitOne(timeoutInMs, false))
{
socket = null;
connectAbandon.Cancel(asyncResult);
TcpChannel.ThrowTimeoutException(netPath.TargetNodeName, ReplayStrings.NetworkConnectionTimeout(timeoutInMs / 1000));
}
socket.EndConnect(asyncResult);
long elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
ExTraceGlobals.TcpClientTracer.TraceDebug <long>(0L, "Connection took {0}ms", elapsedMilliseconds);
socket.LingerState = new LingerOption(true, 0);
if (!netPath.UseSocketStream || RegistryParameters.DisableSocketStream)
{
stream = new NetworkStream(socket, false);
}
else
{
stream = new SocketStream(socket, netPath.SocketStreamBufferPool, netPath.SocketStreamAsyncArgPool, netPath.SocketStreamPerfCounters);
}
negotiateStream = new NegotiateStream(stream, false);
stream = null;
elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
if (elapsedMilliseconds >= (long)timeoutInMs)
{
TcpChannel.ThrowTimeoutException(netPath.TargetNodeName, ReplayStrings.NetworkConnectionTimeout(timeoutInMs / 1000));
}
int num = timeoutInMs - (int)elapsedMilliseconds;
negotiateStream.WriteTimeout = num;
negotiateStream.ReadTimeout = num;
TcpClientChannel.AuthAbandon authAbandon = new TcpClientChannel.AuthAbandon(socket, negotiateStream);
string targetName;
if (netPath.UseNullSpn)
{
targetName = "";
}
else
{
targetName = "HOST/" + netPath.TargetNodeName;
}
bool encrypt = netPath.Encrypt;
ProtectionLevel protectionLevel;
if (encrypt)
{
protectionLevel = ProtectionLevel.EncryptAndSign;
}
else if (RegistryParameters.DisableNetworkSigning)
{
protectionLevel = ProtectionLevel.None;
}
else
{
protectionLevel = ProtectionLevel.Sign;
}
asyncResult = negotiateStream.BeginAuthenticateAsClient(CredentialCache.DefaultNetworkCredentials, targetName, protectionLevel, TokenImpersonationLevel.Identification, null, authAbandon);
if (!asyncResult.AsyncWaitHandle.WaitOne(num, false))
{
negotiateStream = null;
socket = null;
authAbandon.Abandon(asyncResult);
TcpChannel.ThrowTimeoutException(netPath.TargetNodeName, ReplayStrings.NetworkConnectionTimeout(timeoutInMs / 1000));
}
negotiateStream.EndAuthenticateAsClient(asyncResult);
bool flag = false;
if (!negotiateStream.IsAuthenticated)
{
flag = true;
}
else if (protectionLevel != ProtectionLevel.None && !negotiateStream.IsMutuallyAuthenticated)
{
if (netPath.IgnoreMutualAuth || MachineName.Comparer.Equals(netPath.TargetNodeName, Environment.MachineName))
{
ExTraceGlobals.TcpClientTracer.TraceDebug(0L, "Ignoring mutual auth since we are local");
}
else
{
flag = true;
}
}
if (!flag && encrypt && !negotiateStream.IsEncrypted)
{
ExTraceGlobals.TcpClientTracer.TraceError(0L, "Encryption requested, but could not be negotiated");
flag = true;
}
if (flag)
{
ExTraceGlobals.TcpClientTracer.TraceError <bool, bool, bool>(0L, "Security Negotiation failed. Auth={0},MAuth={1},Encrypt={2}", negotiateStream.IsAuthenticated, negotiateStream.IsMutuallyAuthenticated, negotiateStream.IsEncrypted);
NetworkManager.ThrowException(new NetworkCommunicationException(netPath.TargetNodeName, ReplayStrings.NetworkSecurityFailed));
}
ExTraceGlobals.TcpClientTracer.TraceDebug <long, bool, ProtectionLevel>(0L, "Authenticated Connection took {0}ms. Encrypt={1} ProtRequested={2}", replayStopwatch.ElapsedMilliseconds, negotiateStream.IsEncrypted, protectionLevel);
channel = new TcpClientChannel(netPath.TargetNodeName, socket, negotiateStream, timeoutInMs);
return(true);
}
catch (SocketException ex2)
{
ex = ex2;
}
catch (IOException ex3)
{
ex = ex3;
}
catch (AuthenticationException ex4)
{
ex = ex4;
}
catch (NetworkTransportException ex5)
{
ex = ex5;
}
finally
{
if (channel == null)
{
if (negotiateStream != null)
{
negotiateStream.Dispose();
}
else if (stream != null)
{
stream.Dispose();
}
if (socket != null)
{
socket.Close();
}
}
else
{
ReplayCrimsonEvents.NetworkConnectionSuccess.Log <string, IPEndPoint, IPEndPoint>(netPath.TargetNodeName, netPath.TargetEndPoint, channel.LocalEndpoint);
}
}
ExTraceGlobals.TcpClientTracer.TraceError <Exception>(0L, "TryOpenChannel failed. Ex={0}", ex);
ReplayCrimsonEvents.NetworkConnectionFailure.Log <string, IPEndPoint, IPEndPoint, string>(netPath.TargetNodeName, netPath.TargetEndPoint, netPath.SourceEndPoint, ex.ToString());
if (ex is NetworkTransportException)
{
networkEx = (NetworkTransportException)ex;
}
else
{
networkEx = new NetworkCommunicationException(netPath.TargetNodeName, ex.Message, ex);
}
return(false);
}
private static void Connect(string username = null, string password = null, string host = "localhost", int addressIndex = 1, int port = 11000)
{
// Get IP address.
var ipAddress = Dns.GetHostEntry(host).AddressList[addressIndex];
// Get remote end point.
var endPoint = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
_client = new TcpClient();
// Connect the socket to the remote endpoint.
_client.Connect(endPoint);
Logging.Log($"Client successfully connected to {endPoint}.");
// Keep connection alive if transfer isn't complete.
_client.LingerState = new LingerOption(true, 0);
// Get negotiation stream from client.
var negotiateStream = new NegotiateStream(_client.GetStream(), false);
// Pass the NegotiateStream as the AsyncState object
// so that it is available to the callback delegate.
IAsyncResult asyncResult;
// If username/password provided, use as credentials.
if (username != null && password != null)
{
asyncResult = negotiateStream.BeginAuthenticateAsClient(
new NetworkCredential("username", "password"),
host,
EndAuthenticateCallback,
negotiateStream);
}
else
{
// Use Identification ImpersonationLevel
asyncResult = negotiateStream.BeginAuthenticateAsClient(
EndAuthenticateCallback,
negotiateStream
);
}
Logging.Log("Client attempting to authenticate.");
// Await result.
asyncResult.AsyncWaitHandle.WaitOne();
// Send encoded test message to server.
var message = Encoding.UTF8.GetBytes("Hello, it's me, the client!");
asyncResult = negotiateStream.BeginWrite(
message,
0,
message.Length,
EndWriteCallback,
negotiateStream);
// Await result.
asyncResult.AsyncWaitHandle.WaitOne();
Logging.Log($"Successfully sent message containing {message.Length} bytes.");
// Close the client connection.
negotiateStream.Close();
Logging.Log("Client closed.");
}