title: SSL Certification works with localhost but not computer name or ip
body: <p>We have a web application running on server and it posts http requests via XDomainRequest (because of IE9). </p>
  
  <p>There are lots of client computers which have a console application listening on a port via socket listener. Clients open web application with their
  IE9 browsers and when they click on a link, the web page sends requests like that:</p>
  
  <p>"<a href="https://localhost:portNumber/applicationName/doSomething" rel="noreferrer">https://localhost:portNumber/applicationName/doSomething</a>"
  "<a href="https://computerName:portNumber/applicationName/doSomething" rel="noreferrer">https://computerName:portNumber/applicationName/doSomething</a>" 
  "<a href="https://ipAddress:portNumber/applicationName/doSomething" rel="noreferrer">https://ipAddress:portNumber/applicationName/doSomething</a>"</p>
  
  <p>The second and third requests are made to console applications of other users' computers.</p>
  
  <p>The problem is that if requests come with localhost, console application does not have a problem about reading incoming data and sending response back. But 
  if the request comes with computer name or ip address then browser shows certification warning and wants user to click on 
  "Continue to this web site (not recommended)" link.</p>
  
  <p>We thought creating three different certificates via code.
  But even using sslstream with three of them is possible we cannot decide to select true certification because we make authenticatiton first and then receive data. So when we catch incoming request the authentication must already be done.</p>
  
  <p>Another way is forcing socket listener or sslstream to behave all these three requests as if they are localhost. So for each one authentication will be made as localhost. But I could not find an actual way for that.</p>
  
  <p>Here is the code. I give the code because maybe there is some wrong usage of SslStream.</p>
  
  <pre><code>using System;
  using System.Net.Sockets;
  using System.Net;
  using System.Configuration;
  using System.Security.Cryptography.X509Certificates;
  using System.Windows.Forms;
  using System.IO;
  using System.Net.Security;
  using System.Security.Authentication;
  using System.Threading;
  using System.Text;
  
  namespace StackOverFlowProject
  {
      class StackOverFlowSample
      {
          private static ManualResetEvent _manualResetEvent = new ManualResetEvent(false);
          private static X509Certificate _cert = null;
  
          static void Main(string[] args)
          {
              StackOverFlowSample stackOverFlowSample = new StackOverFlowSample();
              stackOverFlowSample.StartListening();
          }
  
          private void StartListening()
          {
              GetCertificate();
  
              IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 1234);
  
              if (localEndPoint != null)
              {
                  Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  
                  if (listener != null)
                  {
                      listener.Bind(localEndPoint);
                      listener.Listen(10);
  
                      Console.WriteLine("Socket listener is running. Waiting for requests...");
  
                      listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                  }
              }
          }
  
          private static void GetCertificate()
          {
              byte[] pfxData = File.ReadAllBytes(Application.StartupPath + @"\" + "localhost.pfx");
  
              _cert = new X509Certificate2(pfxData, "password", X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
          }
  
  
          private void AcceptCallback(IAsyncResult result)
          {
              Socket listener = null;
              Socket handler = null;
              StateObject state = null;
              SslStream sslStream = null;
  
              _manualResetEvent.Set();
  
              listener = (Socket)result.AsyncState;
  
              handler = listener.EndAccept(result);
  
              state = new StateObject();
  
              if (handler.RemoteEndPoint != null)
              {
                  state.clientIP = ((IPEndPoint)handler.RemoteEndPoint).Address.ToString();
              }
  
              sslStream = new SslStream(new NetworkStream(handler, true));
              sslStream.AuthenticateAsServer(_cert, false, SslProtocols.Tls, true);
  
              sslStream.ReadTimeout = 100000;
              sslStream.WriteTimeout = 100000;
  
              state.workStream = sslStream;
  
              if (state.workStream.IsAuthenticated)
              {
                  state.workStream.BeginRead(state.buffer, 0, StateObject.BufferSize, ReceiveCallback, state);
              }
  
              listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
          }
  
          private void ReceiveCallback(IAsyncResult result)
          {
              StateObject stateObject = null;
              SslStream sslStreamReader = null;
  
              byte[] byteData = null;
  
              stateObject = (StateObject)result.AsyncState;
              sslStreamReader = stateObject.workStream;
  
              int byteCount = sslStreamReader.EndRead(result);
  
              Decoder decoder = Encoding.UTF8.GetDecoder();
              char[] chars = new char[decoder.GetCharCount(stateObject.buffer, 0, byteCount)];
              decoder.GetChars(stateObject.buffer, 0, byteCount, chars, 0);
              stateObject.sb.Append(chars);
  
              if (byteCount &gt; 0)
              {
                  stateObject.totalReceivedBytes += byteCount;
  
                  string[] lines = stateObject.sb.ToString().Split('\n');
  
                  if (lines[lines.Length - 1] != "&lt;EOF&gt;")
                  {
                      // We didn't receive all data. Continue reading...
                      sslStreamReader.BeginRead(stateObject.buffer, 0, stateObject.buffer.Length, new AsyncCallback(ReceiveCallback), stateObject);
                  }
                  else
                  {
                      Console.WriteLine("We received all data. Sending response...");
  
                      byteData = Encoding.UTF8.GetBytes("Hello! I received your request!");
  
                      string httpHeaders = "HTTP/1.1" + "\r\n"
                                      + "Cache-Control: no-cache" + "\r\n"
                                      + "Access-Control-Allow-Origin: *" + "\r\n"
                                      + "\r\n";
  
                      byte[] byteHttpHeaders = Encoding.UTF8.GetBytes(httpHeaders);
  
                      byte[] concat = new byte[byteHttpHeaders.Length + byteData.Length];
                      Buffer.BlockCopy(byteHttpHeaders, 0, concat, 0, byteHttpHeaders.Length);
                      Buffer.BlockCopy(byteData, 0, concat, byteHttpHeaders.Length, byteData.Length);
  
                      stateObject.sslStreamReader = sslStreamReader;
  
                      sslStreamReader.BeginWrite(concat, 0, concat.Length, new AsyncCallback(SendCallback), stateObject);
                  }
              }
          }
  
          private void SendCallback(IAsyncResult ar)
          {
              SslStream sslStreamSender = null;
  
              StateObject stateObject = (StateObject)ar.AsyncState;
  
              sslStreamSender = stateObject.sslStreamReader;
              sslStreamSender.EndWrite(ar);
  
              Console.WriteLine(stateObject.totalReceivedBytes.ToString() + " bytes sent to " + stateObject.clientIP + " address");
  
              sslStreamSender.Close();
              sslStreamSender.Dispose();
          }
  
      }
  
      public class StateObject
      {
          public SslStream workStream = null;
  
          public SslStream sslStreamReader = null;
  
          public const int BufferSize = 1024;
          public byte[] buffer = new byte[BufferSize];
          public StringBuilder sb = new StringBuilder();
  
          public string clientIP = "";
  
          public int totalReceivedBytes = 0;
      }
  }
  </code></pre>