System.Net.Security.NegotiateStream

Client Example

using System;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Security.Authentication;
using System.Text;

public class ClientExample
{
    public static void Main(string[] args)
    {
        try
        {
            // Assuming a server is listening on localhost:8080
            TcpClient client = new TcpClient("localhost", 8080);
            NetworkStream stream = client.GetStream();

            // Create a NegotiateStream using the underlying network stream
            // The 'true' indicates that NegotiateStream owns the underlying stream
            NegotiateStream negotiateStream = new NegotiateStream(stream, true);

            // Authenticate as a client.
            // null for the target name means it will try to infer from the server name.
            // null for the certificate means default certificate validation.
            // SslProtocols.Tls implies using TLS if available, falling back to Negotiate
            negotiateStream.AuthenticateAsClient("localhost", null, SslProtocols.Tls, false);

            Console.WriteLine("Client authenticated successfully.");
            Console.WriteLine($"IsAuthenticated: {negotiateStream.IsAuthenticated}");
            Console.WriteLine($"IsMutuallyAuthenticated: {negotiateStream.IsMutuallyAuthenticated}");

            // Send data
            string message = "Hello from the authenticated client!";
            byte[] messageBytes = Encoding.UTF8.GetBytes(message);
            negotiateStream.Write(messageBytes, 0, messageBytes.Length);
            negotiateStream.Flush();
            Console.WriteLine("Sent: " + message);

            // Receive data
            byte[] buffer = new byte[1024];
            int bytesRead = negotiateStream.Read(buffer, 0, buffer.Length);
            string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received: " + response);

            negotiateStream.Close(); // This will also close the underlying stream
            client.Close();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}
                

Server Example

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;

public class ServerExample
{
    public static void Main(string[] args)
    {
        TcpListener listener = new TcpListener(IPAddress.Any, 8080);
        listener.Start();
        Console.WriteLine("Server started. Listening on port 8080...");

        try
        {
            while (true)
            {
                TcpClient client = listener.AcceptTcpClient();
                Console.WriteLine("Client connected.");
                HandleClient(client);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Server Error: " + ex.Message);
        }
        finally
        {
            listener.Stop();
        }
    }

    private static void HandleClient(TcpClient tcpClient)
    {
        NetworkStream stream = tcpClient.GetStream();
        // Load your server certificate here. For testing, you might use a self-signed certificate.
        // In production, ensure you use a trusted certificate.
        X509Certificate serverCertificate = LoadCertificate();

        // Create a NegotiateStream
        NegotiateStream negotiateStream = new NegotiateStream(stream, true);

        try
        {
            // Authenticate as a server.
            negotiateStream.AuthenticateAsServer(serverCertificate, SslProtocols.Tls, false);

            Console.WriteLine("Server authenticated successfully.");
            Console.WriteLine($"IsAuthenticated: {negotiateStream.IsAuthenticated}");
            Console.WriteLine($"IsMutuallyAuthenticated: {negotiateStream.IsMutuallyAuthenticated}");

            // Receive data
            byte[] buffer = new byte[1024];
            int bytesRead = negotiateStream.Read(buffer, 0, buffer.Length);
            string message = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received: " + message);

            // Send a response
            string responseMessage = "Message received by the server!";
            byte[] responseBytes = Encoding.UTF8.GetBytes(responseMessage);
            negotiateStream.Write(responseBytes, 0, responseBytes.Length);
            negotiateStream.Flush();
            Console.WriteLine("Sent: " + responseMessage);
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error handling client: " + ex.Message);
        }
        finally
        {
            negotiateStream.Close(); // This will also close the underlying stream
            tcpClient.Close();
            Console.WriteLine("Client disconnected.");
        }
    }

    private static X509Certificate LoadCertificate()
    {
        // In a real application, load the certificate from a file or the certificate store.
        // For example purposes, this might return null or a placeholder.
        // Ensure you have a valid certificate for production use.
        // Example: X509Certificate2 cert = new X509Certificate2("server.pfx", "password");
        // return cert;
        Console.WriteLine("Warning: No server certificate loaded. Authentication may fail.");
        return null; // Or load a test certificate
    }
}