Hello,

I have written a small application (A) that connects to a web site
through SSL, sends a request and receives a response. This application
works fine. In particular, the SSL handshake takes less than 0.20 sec.

If I use the exact same piece of code inside a very simple Windows
service (B), the SSL handshake lasts between 15 and 20 sec (!) - it
does not fail though. However, the web site Im connecting to times out
on reading the request I am supposed to send him

I have enabled tracing for the .NET network stack. There is no
difference between A and B.

Questions :
1) Is there anything I don't know regarding windows services and
SslStream objects ?
2) If I repeat the requests 3 times, in each case the SSL handshake
takes much less time than the very first one. I'd be interested in
knowing what is happening. Is the certificate cached ?

Thanks

Tibo

See below for the code used:
*******************************************************
(A)
using System;
using TestSSL;
using log4net.Config;
using log4net;

namespace ConsoleApplication1
{
   class Program
   {
       private static readonly ILog log =
LogManager.GetLogger(typeof(Program));

       static void Main(string[] args)
       {
           BasicConfigurator.Configure();
           log.Info("Starting test program ...");
           SSLRequest test = new SSLRequest();
           test.TestConnection(null);
      }
   }
}

(B)
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
using System.Threading;

namespace TestSSL
{
   public partial class Service1 : ServiceBase
   {
       public Service1()
       {
           InitializeComponent();
       }

       protected override void OnStart(string[] args)
       {
           SSLRequest test = new SSLRequest();
           ThreadPool.QueueUserWorkItem(new
WaitCallback(test.TestConnection));
       }

       protected override void OnStop()
       {
       }
   }
}

(Common lib :)

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Net.Security;
using System.Net;
using System.Security.Cryptography.X509Certificates;
using log4net;
using System.Configuration;

namespace TestSSL
{
   public class SSLRequest
   {
       private static readonly ILog log =
LogManager.GetLogger(typeof(SSLRequest));

       public SSLRequest()
       {
       }

       public void TestConnection(Object stateInfo)
       {
           NetworkStream stream = null;

           string Server = ConfigurationManager.AppSettings["Server"];
           int Port =
Int32.Parse(ConfigurationManager.AppSettings["Port"]);
           string CertificateSubject =
ConfigurationManager.AppSettings["CertificateSubject"];

           try
           {
               for (int i = 0; i < 3; i++)
               {
                   IPAddress ipAddress = IPAddress.Parse(Server);
                   IPEndPoint connectPoint = new IPEndPoint(ipAddress,
Port);
                   Socket socket = new
Socket(AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
                   socket.SetSocketOption(SocketOptionLevel.Socket,
SocketOptionName.ReuseAddress, 1);
                   socket.Connect(connectPoint);
                   stream = new NetworkStream(socket);

                   RemoteCertificateValidationCallback callback = new
RemoteCertificateValidationCallback(OnCertificateValidation);

                   SslStream sslStream = new SslStream(stream, false,
callback);

                   DateTime start = DateTime.Now;
                   sslStream.AuthenticateAsClient(CertificateSubject);
                   DateTime end = DateTime.Now;

                   log.Info("SSL Handshake : "+(end - start));

                   string request = <xml request>

                   byte[] ByteRequest =
Encoding.ASCII.GetBytes(request);

                   log.Info("SslStream IsEncrypted " +
sslStream.IsEncrypted);
                   log.Info("SslStream IsMutuallyAuthenticated " +
sslStream.IsMutuallyAuthenticated);
                   log.Info("SslStream IsSigned " +
sslStream.IsSigned);
                   log.Info("SslStream KeyExchangeAlgorithm " +
sslStream.KeyExchangeAlgorithm);

                   log.Info("Sending request ...");
                   sslStream.Write(ByteRequest, 0,
ByteRequest.Length);

                   byte[] ByteResponse = new byte[2048];

                   log.Info("Receiving response ...");
                   sslStream.Read(ByteResponse, 0,
ByteResponse.Length);

                   log.Info("Response : " +
Encoding.ASCII.GetString(ByteResponse, 0, ByteResponse.Length));
               }
           }
           catch (Exception e)
           {
               log.Error("Exception : ", e);
           }
       }

       protected static bool OnCertificateValidation(object sender,
X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
       {
           return true;
       }
   }
}

*******************************************************