Example

The following C# code demonstrates how to use CertificateDelegationType when authenticating as a server using NegotiateStream.

using System;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;

public class ServerExample
{
    public static async Task StartServer(int port)
    {
        TcpListener listener = new TcpListener(System.Net.IPAddress.Any, port);
        listener.Start();
        Console.WriteLine($"Server started on port {port}. Waiting for connections...");

        while (true)
        {
            TcpClient client = await listener.AcceptTcpClientAsync();
            _ = HandleClientAsync(client); // Fire and forget
        }
    }

    private static async Task HandleClientAsync(TcpClient tcpClient)
    {
        X509Certificate2 serverCertificate = GetServerCertificate(); // Implement this to get your server cert

        using (NetworkStream networkStream = tcpClient.GetStream())
        {
            // Specify CertificateDelegationType.Full for example
            using (SslStream sslStream = new SslStream(networkStream, false))
            {
                try
                {
                    await sslStream.AuthenticateAsServerAsync(serverCertificate,
                                                              clientCertificateRequired: true,
                                                              enabledSslProtocols: System.Security.Authentication.SslProtocols.Tls12,
                                                              checkCertificateRevocation: true,
                                                              certificateDelegationType: CertificateDelegationType.Full); // Using Full delegation

                    Console.WriteLine("Client authenticated successfully.");

                    // Perform secure communication here...
                    byte[] buffer = new byte[1024];
                    int bytesRead = await sslStream.ReadAsync(buffer, 0, buffer.Length);
                    string request = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
                    Console.WriteLine($"Received: {request}");

                    string response = "Hello from server!";
                    byte[] responseData = System.Text.Encoding.UTF8.GetBytes(response);
                    await sslStream.WriteAsync(responseData, 0, responseData.Length);

                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Authentication failed: {ex.Message}");
                }
            }
        }
        tcpClient.Close();
    }

    private static X509Certificate2 GetServerCertificate()
    {
        // In a real application, you would load your certificate securely
        // For example, from a file or the certificate store.
        // Replace with your actual certificate path and password.
        // string certificatePath = "path/to/your/server.pfx";
        // string certificatePassword = "your_password";
        // return new X509Certificate2(certificatePath, certificatePassword);

        // Placeholder: return a dummy certificate or null if not required for basic demo
        Console.WriteLine("WARNING: Using placeholder for GetServerCertificate(). Implement loading your actual server certificate.");
        return null; // Or load a valid certificate for real use
    }

    public static async Task Main(string[] args)
    {
        // await StartServer(12345); // Example port
    }
}