C＃でクライアントによるサーバー認証のためにサーバー名を識別するにはどうすればよいですか？

Question

私は最近、C＃でSSL暗号化サーバー/クライアントを作成しようとしています。

私はMSDNの this チュートリアルに従いましたが、makecert.exeを使用してサーバーとクライアントで使用するための証明書を作成する必要があったため、例とそれは素晴らしい証明書を作成しました：

makecert -sr LocalMachine -ss My -n "CN = Test" -sky exchange -sk 123456 c：/Test.cer

しかし、問題はサーバーが起動してクライアントを待機することです。クライアントが接続すると、マシン名が使用されます。この場合、収集できるのは私のIPです。

127.0.0.1

、次に、証明書のサーバー名と一致する必要があるサーバー名が必要です（テスト.cer）。複数の組み合わせ（ "Test" "LocalMachine"、 "127.0.0.1"など）を試しましたが、指定されたサーバー名のクライアントを一致させることができないため、接続が許可されます。私が得るエラーは次のとおりです：

証明書エラー：RemoteCertificateNameMismatch、RemoteCertificateChainErrors例外：検証手順に従って、リモート証明書が無効です

これが私が使用しているコードです。MSDNの例とは異なり、アプリでサーバーの証明書パスと、クライアントのマシン名とサーバー名も割り当てています。

SslTcpServer.cs

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

namespace Examples.System.Net
{
    public sealed class SslTcpServer
    {
        static X509Certificate serverCertificate = null;
        // The certificate parameter specifies the name of the file  
        // containing the machine certificate. 
        public static void RunServer(string certificate)
        {
            serverCertificate = X509Certificate.CreateFromCertFile(certificate);
            // Create a TCP/IP (IPv4) socket and listen for incoming connections.
            TcpListener listener = new TcpListener(IPAddress.Any, 8080);
            listener.Start();
            while (true)
            {
                Console.WriteLine("Waiting for a client to connect...");
                // Application blocks while waiting for an incoming connection. 
                // Type CNTL-C to terminate the server.
                TcpClient client = listener.AcceptTcpClient();
                ProcessClient(client);
            }
        }
        static void ProcessClient(TcpClient client)
        {
            // A client has connected. Create the  
            // SslStream using the client's network stream.
            SslStream sslStream = new SslStream(
                client.GetStream(), false);
            // Authenticate the server but don't require the client to authenticate. 
            try
            {
                sslStream.AuthenticateAsServer(serverCertificate,
                    false, SslProtocols.Tls, true);
                // Display the properties and settings for the authenticated stream.
                DisplaySecurityLevel(sslStream);
                DisplaySecurityServices(sslStream);
                DisplayCertificateInformation(sslStream);
                DisplayStreamProperties(sslStream);

                // Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000;
                sslStream.WriteTimeout = 5000;
                // Read a message from the client.   
                Console.WriteLine("Waiting for client message...");
                string messageData = ReadMessage(sslStream);
                Console.WriteLine("Received: {0}", messageData);

                // Write a message to the client. 
                byte[] message = Encoding.UTF8.GetBytes("Hello from the server.<EOF>");
                Console.WriteLine("Sending hello message.");
                sslStream.Write(message);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine("Authentication failed - closing the connection.");
                sslStream.Close();
                client.Close();
                return;
            }
            finally
            {
                // The client stream will be closed with the sslStream 
                // because we specified this behavior when creating 
                // the sslStream.
                sslStream.Close();
                client.Close();
            }
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the client. 
            // The client signals the end of the message using the 
            // "<EOF>" marker.
            byte[] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                // Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8 
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer, 0, bytes)];
                decoder.GetChars(buffer, 0, bytes, chars, 0);
                messageData.Append(chars);
                // Check for EOF or an empty message. 
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes != 0);

            return messageData.ToString();
        }
        static void DisplaySecurityLevel(SslStream stream)
        {
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength);
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength);
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength);
            Console.WriteLine("Protocol: {0}", stream.SslProtocol);
        }
        static void DisplaySecurityServices(SslStream stream)
        {
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted);
        }
        static void DisplayStreamProperties(SslStream stream)
        {
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite);
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout);
        }
        static void DisplayCertificateInformation(SslStream stream)
        {
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus);

            X509Certificate localCertificate = stream.LocalCertificate;
            if (stream.LocalCertificate != null)
            {
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.",
                    localCertificate.Subject,
                    localCertificate.GetEffectiveDateString(),
                    localCertificate.GetExpirationDateString());
            }
            else
            {
                Console.WriteLine("Local certificate is null.");
            }
            // Display the properties of the client's certificate.
            X509Certificate remoteCertificate = stream.RemoteCertificate;
            if (stream.RemoteCertificate != null)
            {
                Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.",
                    remoteCertificate.Subject,
                    remoteCertificate.GetEffectiveDateString(),
                    remoteCertificate.GetExpirationDateString());
            }
            else
            {
                Console.WriteLine("Remote certificate is null.");
            }
        }
        public static void Main(string[] args)
        {
            string certificate = "c:/Test.cer";
            SslTcpServer.RunServer(certificate);
        }
    }
}

SslTcpClient.cs

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

namespace Examples.System.Net
{
    public class SslTcpClient
    {
        private static Hashtable certificateErrors = new Hashtable();

        // The following method is invoked by the RemoteCertificateValidationDelegate. 
        public static bool ValidateServerCertificate(
              object sender,
              X509Certificate certificate,
              X509Chain chain,
              SslPolicyErrors sslPolicyErrors)
        {
            if (sslPolicyErrors == SslPolicyErrors.None)
                return true;

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors);

            // Do not allow this client to communicate with unauthenticated servers. 
            return false;
        }
        public static void RunClient(string machineName, string serverName)
        {
            // Create a TCP/IP client socket. 
            // machineName is the Host running the server application.
            TcpClient client = new TcpClient(machineName, 8080);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback(ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate. 
            try
            {
                sslStream.AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine("Authentication failed - closing the connection.");
                client.Close();
                return;
            }
            // Encode a test message into a byte array. 
            // Signal the end of the message using the "<EOF>".
            byte[] messsage = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
            // Send hello message to the server. 
            sslStream.Write(messsage);
            sslStream.Flush();
            // Read message from the server. 
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);
            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the server. 
            // The end of the message is signaled using the 
            // "<EOF>" marker.
            byte[] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8 
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer, 0, bytes)];
                decoder.GetChars(buffer, 0, bytes, chars, 0);
                messageData.Append(chars);
                // Check for EOF. 
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes != 0);

            return messageData.ToString();
        }
        public static void Main(string[] args)
        {
            string serverCertificateName = null;
            string machineName = null;
            /*
            // User can specify the machine name and server name. 
            // Server name must match the name on the server's certificate. 
            machineName = args[0];
            if (args.Length < 2)
            {
                serverCertificateName = machineName;
            }
            else
            {
                serverCertificateName = args[1];
            }*/
            machineName = "127.0.0.1";
            serverCertificateName = "David-PC";// tried Test, LocalMachine and 127.0.0.1
            SslTcpClient.RunClient(machineName, serverCertificateName);
            Console.ReadKey();
        }
    }
}

編集：

サーバーはクライアント接続とすべてを受け入れますが、クライアントがメッセージを送信するのを待っている間にタイムアウトします。 （証明書のサーバー名がクライアントで提供したものと異なるため、クライアントはサーバーで認証されません）それは明確にするためだけに私の考えです

更新：

回答によると、私は証明書メーカーを次のように変更しました。

makecert -sr LocalMachine -ss My -n "CN = localhost" -sky exchange -sk 123456 c：/Test.cerそして私のクライアントには次のものがあります。

        machineName = "127.0.0.1";
        serverCertificateName = "localhost";// tried Test, LocalMachine and 127.0.0.1
        SslTcpClient.RunClient(machineName, serverCertificateName);

今、私は例外を受け取ります：

RemoteCertificateChainErrors例外：検証手順に従って、リモート証明書が無効です

これはここで発生しています：

  // The server name must match the name on the server certificate. 
            try
            {
                sslStream.AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException e)
            {

                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine("Authentication failed - closing the connection. "+ e.Message);
                client.Close();
                return;
            }  

Answer 1

答えは SslStream.AuthenticateAsClientメソッド 備考セクションにあります：

TargetHostに指定する値は、サーバーの証明書の名前と一致する必要があります。

サーバーに「CN = localhost」という件名の証明書を使用する場合、クライアント側で正常に認証するには、targetHostパラメーターとして「localhost」を指定してAuthenticateAsClientを呼び出す必要があります。証明書のサブジェクトとして「CN = David-PC」を使用する場合は、targetHostとして「David-PC」を指定してAuthenticateAsClientを呼び出す必要があります。 SslStreamは、接続する（そしてAuthenticateAsClientに渡す）サーバー名をサーバーから受信した証明書のサブジェクトと照合することにより、サーバーIDをチェックします。サーバーを実行するマシン名は証明書のサブジェクトの名前と一致し、クライアントでは、接続を開くために使用したものと同じホスト名をAuthenticateAsClientに渡します（この場合はTcpClientを使用）。

ただし、サーバーとクライアント間のSSL接続を正常に確立するには、他の条件があります。AuthenticateAsServerに渡される証明書には秘密鍵が必要であり、クライアントマシンで信頼されている必要があり、SSLセッションを確立するための使用に関連する鍵の使用制限があってはなりません。

コードサンプルに関連するようになりましたが、問題は証明書の生成と使用に関連しています。

• 証明書の発行者を提供していないため、信頼できません。これがRemoteCertificateChainErrors例外の原因です。 makecertの-rオプションを指定して、開発目的で自己署名証明書を作成することをお勧めします。

• 証明書を信頼するには、自己署名してWindows証明書ストアの信頼できる場所に配置するか、署名のチェーンを使用して既に信頼されている認証局にリンクする必要があります。したがって、個人ストアに証明書を配置する-ss Myオプションの代わりに、-ss rootを使用して、信頼されたルート証明機関に証明書を配置し、マシン上で信頼されます（クライアントが実行されていると想定するコードから）サーバーと同じマシン上で、証明書も生成されます）。

• Makecertに出力ファイルを指定すると、証明書は.cerとしてエクスポートされますが、この形式には公開鍵のみが含まれ、サーバーがSSL接続を確立するために必要な秘密鍵は含まれません。最も簡単な方法は、サーバーコードのWindows証明書ストアから証明書を読み取ることです。 （ここで説明するように、秘密鍵を保存できる別の形式でストアからエクスポートすることもできます 秘密鍵を使用して証明書をエクスポートする そしてサーバーコードでそのファイルを読み取ります）。

ここで使用されるmakecertオプションの詳細を見つけることができます 証明書作成ツール（Makecert.exe）

結論として、コードを実行するには、次の変更が必要です（最新のコード更新でテスト済み）。

• 次のコマンドを使用して、証明書を生成します。

makecert -sr LocalMachine -ss root -r -n "CN = localhost" -sky exchange -sk 123456

• （この例を簡単にするために）ファイルではなくWindows証明書ストアから証明書を読み取るので、置き換えます

serverCertificate = X509Certificate.CreateFromCertFile（certificate）;

サーバーコード内：

X509Store store = new X509Store(StoreName.Root, StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadOnly);
var certificates = store.Certificates.Find(X509FindType.FindBySubjectDistinguishedName, "CN=localhost", false);
store.Close();

if (certificates.Count == 0)
{
    Console.WriteLine("Server certificate not found...");
    return;
}
else
{
    serverCertificate = certificates[0];
}

後でコードを変更する場合は、「CN = localhost」を使用する証明書の件名に置き換えることを忘れないでください（この状況では、makecertに渡される-nオプションと同じ値にする必要があります）。また、サーバー証明書のサブジェクトでlocalhostの代わりにサーバーを実行するマシン名を使用することを検討してください。

Answer 2

サーバー証明書のCNは、サーバーのドメイン名と完全に同じである必要があります。あなたの場合、一般名は「localhost」（引用符なし）でなければならないと思います。

重要：確かに、他の回答を読んだことがあるかもしれませんが、本番環境ではCN="localhost"を使用しないでください。

Answer 3

まず、件名が「CN = localhost」または同等の証明書を作成しないでください。本番環境で使用されることは決してないので、使用しないでください。常にコンピュータのホスト名に発行してください。 CN = "mycomputer"であり、ローカルホストではなくホスト名を使用して接続します。 「サブジェクト代替名」拡張子を使用して複数の名前を指定できますが、makecertはそれをサポートしていないようです。

次に、サーバーSSL証明書を発行するときに、「サーバー認証」OIDを証明書の拡張キー使用法（EKU）拡張機能に追加する必要があります。-eku 1.3.6.1.5.5.7.3.1パラメーターをに追加します。例ではmakecert。クライアント証明書認証を実行する場合は、「クライアント認証」OID of1.3.6.1.5.5.7.3.2。

最後に、makecertによって作成されたデフォルトの証明書は、ハッシュアルゴリズムとしてMD5を使用します。 MD5は安全でないと見なされ、テストには影響しませんが、SHA1を使用する習慣を身に付けます。上記のmakecertパラメータに-a sha1を追加して、SHA1を強制します。デフォルトのキーサイズも1024ビットから2048ビットに増やす必要がありますが、あなたはその考えを理解しています。

Answer 4

やってみました：？

example.netのような完全なドメイン名（意図的に本名ではないものにはexample.net、example.com、またはexample.orgを使用することをお勧めします）または名前の証明書を作成しますそれが単一のサイトであり、それがどうなるかを知っている場合は、ライブで使用してください。

その名前に127.0.0.1を使用するようにhostsファイルを更新します。

Answer 5

あなたのアップデートに関して：

SslStreamコンストラクターの1つ これにより、 RemoteCertificateValidationCallbackデリゲート を提供できます。指定したメソッドにブレークポイントを設定して、実際に発生しているエラーを確認できるはずです。 SslPolicyErrors で送信された値を確認してください。

Answer 6

これをWCFで機能させるには、最初に自己署名ルート認証局証明書を作成してから、それを使用してローカルホストの証明書を作成する必要があります。

あなたのプロジェクトにも同じことが当てはまると思います。詳細については、この記事をご覧ください 方法：開発中に使用する一時証明書を作成する 。