title: How to apply PFX certificate file to SslStream socket listener?
body: <p>I have a multi threaded socket listener. It listens on a port. It receives data from HTTP web sites and sends response according to their request. It works good.</p>
  
  <p>Now I want to do same thing with an HTTPS web site. So I changed it to be able to read and write via SslStream instead of socket. </p>
  
  <p>The web site owner gave me a pfx file and a password. I placed it into the trusted certificates list of my local certification store. </p>
  
  <p>The certification file is retreived from the store successfully. But after calling AuthenticateAsServer method my handler socket seems to be empty. So I cannot see any data in it inside the ReceiveCallBack method.</p>
  
  <p>How can I apply pfx certificate to my SslStream socket?</p>
  
  <p>Here is my code:</p>
  
  <pre><code>using System;
  using System.Net;
  using System.Net.Sockets;
  using System.Net.Security;
  using System.Threading;
  using System.Security.Cryptography.X509Certificates;
  using System.Text;
  using System.IO;
  
  namespace SslStreamTestApp
  {
      public class SslStreamSocketListener
      {
          private static readonly ManualResetEvent _manualResetEvent = new ManualResetEvent(false);
          private readonly string pfxSerialNumber = "12345BLABLABLA";
  
          X509Certificate _cert = null;
  
          private void GetCertificate()
          {
              X509Store store = new X509Store(StoreName.Root, StoreLocation.CurrentUser);
  
              store.Open(OpenFlags.ReadOnly);
  
              X509Certificate2Collection certificateCollection = store.Certificates.Find(X509FindType.FindBySerialNumber, pfxSerialNumber, true);
  
              if (certificateCollection.Count == 1)
              {
                  _cert = certificateCollection[0];
              }
          }
  
          private void StartListening()
          {
              GetCertificate();
  
              IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 9002);
  
              if (localEndPoint != null)
              {
                  Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  
                  if (listener != null)
                  {
                      listener.Bind(localEndPoint);
                      listener.Listen(5);
  
                      Console.WriteLine("Socket listener is running...");
  
                      listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                  }
              }
          }
  
          private void AcceptCallback(IAsyncResult ar)
          {
              _manualResetEvent.Set();
  
              Socket listener = (Socket)ar.AsyncState;
  
              Socket handler = listener.EndAccept(ar);
  
              SslStream stream = new SslStream(new NetworkStream(handler, true));
              stream.AuthenticateAsServer(_cert, false, System.Security.Authentication.SslProtocols.Ssl3, true);
  
              StateObject state = new StateObject();
              state.workStream = stream;
  
              stream.BeginRead(state.buffer, 0, StateObject.BufferSize, ReceiveCallback, state);
  
              listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
          }
  
          private void ReceiveCallback(IAsyncResult result)
          {
              StateObject state = (StateObject)result.AsyncState;
              SslStream stream = state.workStream;
  
              // Check how many bytes received
              int byteCount = stream.EndRead(result);
  
              Decoder decoder = Encoding.UTF8.GetDecoder();
  
              char[] chars = new char[decoder.GetCharCount(state.buffer, 0, byteCount)];
  
              decoder.GetChars(state.buffer, 0, byteCount, chars, 0);
  
              state.sb.Append(chars);
  
              string check = state.sb.ToString();
  
              if (state.sb.ToString().IndexOf("&lt;EOF&gt;") == -1 &amp;&amp; byteCount != 0)
              {
                  // We didn't receive all data. Continue receiving...
                  stream.BeginRead(state.buffer, 0, state.buffer.Length, new AsyncCallback(ReceiveCallback), stream);
              }
              else
              {
                  string[] lines = state.sb.ToString().Split('\n');
  
                  // send test message to client
                  byte[] test = Encoding.UTF8.GetBytes("\"infoMessage\":\"test\"");
                  stream.BeginWrite(test, 0, test.Length, WriteAsyncCallback, stream);
              }
          }
  
          private void WriteAsyncCallback(IAsyncResult ar)
          {
              SslStream sslStream = (SslStream)ar.AsyncState;
  
              Console.WriteLine("Sending message to client...");
  
              try
              {
                  sslStream.EndWrite(ar);
              }
              catch (IOException)
              {
                  Console.WriteLine("Unable to complete send.");
              }
              finally
              {
                  sslStream.Close();
              }
          }
      }
  
      public class StateObject
      {
          public SslStream workStream = null;
          public const int BufferSize = 1024;
          public byte[] buffer = new byte[BufferSize];
          public StringBuilder sb = new StringBuilder();
      }
  }
  </code></pre>
  
  <p><strong>EDIT:</strong>
  I think I have some problem about SSL logic. PFX file belongs to HTTPS web site. But requests come from HTTPS to my socket listener. Then my socket listener sends response. In this situation, am I server or client? Will I use AuthenticateAsServer or AuthenticateAsClient? </p>
  
  <p>It does not throw error if I call AuthenticateAsServer. It becomes Authenticated with no problem. But I cannot carry the data in handler socket to ReceiveCallBack method via the SslStream of my StateObject.</p>