单线程使用中的线程安全OpenSSL

Threadsafe OpenSSL in a single-threaded use?

本文关键字：线程 安全 OpenSSL 单线程      更新时间：2023-10-16

我已经完全重写了这个问题，因为希望我能通过这种方式得到一些更有用的答案。

我有一个多线程客户端/服务器应用程序，它有一个winsock2套接字，用来"打电话回家"获取客户端的唯一信息。所有套接字通信在使用SSL_write发送之前都使用OpenSSL加密，然后使用SSL_read解密。我们在Socket包装类内部使用阻塞套接字和berkely风格的C调用，使其成为面向对象的。这个Socket类在一个线程中只有一个实例被实例化，对它的所有调用都是在这个线程中串行完成的。客户端"打电话回家"的服务器运行在server 2008 R2机箱上。在从2000到7的所有版本的windows上，客户端都能完美地工作：它可以握手，获得所需的信息，并干净地关闭连接。

在Windows 8中，客户端会在没有解释的情况下使"呼叫总部"失败，并使服务器处于尝试不断从套接字读取更多信息的状态。

一位同事向我建议的一件事是确保我的OpenSSL设置为线程安全。

由于几个原因，我认为这是不必要的，但我需要一个更明智的答案
原因1:所有套接字I/O都发生在单个线程中
原因2:所有套接字调用都以串行顺序发生
原因3：它适用于8之前的所有早期版本的Windows。

将OpenSSL设置为线程安全是否重要

设置OpenSSL回调以确保线程安全已经足够容易了，为什么不直接这样做，看看问题是否消失。

虽然你认为没有必要这样做，但存在潜在问题的事实不应该让你忽视潜在的简单解决方案，即使"不可能"。。。

这是我使用的代码，

struct CRYPTO_dynlock_value 
{ 
   CRYPTO_dynlock_value()
   {
      ::InitializeCriticalSection(&crit);
   }
   ~CRYPTO_dynlock_value()
   {
      ::DeleteCriticalSection(&crit);
   }
    CRITICAL_SECTION crit;
}; 
static CRITICAL_SECTION *InitStaticCrit()
{
   CRITICAL_SECTION *pCrit = new CRITICAL_SECTION();
   ::InitializeCriticalSection(pCrit);
   return pCrit;
}
static CRITICAL_SECTION *s_pCriticalSection = InitStaticCrit();
static CRITICAL_SECTION *s_pLocks = 0;
static struct CRYPTO_dynlock_value *dyn_create_function(
   const char *file,
   int line) 
{
   (void)file;
   (void)line;
   CRYPTO_dynlock_value *pValue = new CRYPTO_dynlock_value();
   return pValue;
}
static void dyn_lock_function(
   int mode,
   struct CRYPTO_dynlock_value *pLock,
   const char *file,
   int line) 
{
   (void)file;
   (void)line;
    if (mode & CRYPTO_LOCK)
    {
       ::EnterCriticalSection(&pLock->crit);
    }
    else
    {
       ::LeaveCriticalSection(&pLock->crit);
    } 
} 
static void dyn_destroy_function(
   struct CRYPTO_dynlock_value *pLock,
   const char *file,
   int line) 
{
   (void)file;
   (void)line;
   delete pLock;
}
static bool ThreadingSetup(
   const DWORD spinCount)
{
   ::EnterCriticalSection(&s_criticalSection);
   bool ok = false;
   if (!s_pLocks)
   {
      s_pLocks = (CRITICAL_SECTION *)malloc(CRYPTO_num_locks() * sizeof(CRITICAL_SECTION));
      for (int i = 0; i < CRYPTO_num_locks(); i++)
      {
         if (spinCount != 0)
         {
#if(_WIN32_WINNT >= 0x0403)
            (void)::InitializeCriticalSectionAndSpinCount(&s_pLocks[i], spinCount);
#else
#pragma warning(suppress: 6011)  // Dereferencing null pointer. No, we're not.
            ::InitializeCriticalSection(&s_pLocks[i]);
            OutputDebugString(_T("CUsesOpenSSL::ThreadingSetup() - spin count specified but _WIN32_WINNT < 0x0403, spin count not usedn"));
#endif
         }
         else
         {
#pragma warning(suppress: 6011)  // Dereferencing null pointer. No, we're not.
            ::InitializeCriticalSection(&s_pLocks[i]);
         }
      }
      CRYPTO_set_locking_callback(LockingCallback);
      //CRYPTO_set_id_callback(id_function); 
      // dynamic locks callbacks
      CRYPTO_set_dynlock_create_callback(dyn_create_function); 
      CRYPTO_set_dynlock_lock_callback(dyn_lock_function); 
      CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function); 
      ok = true;
   }
   ::LeaveCriticalSection(&s_criticalSection);
   return ok;
}
static void ThreadingCleanup()
{
   if (s_pLocks)
   {
      CRYPTO_set_locking_callback(0);
      CRYPTO_set_dynlock_create_callback(0);
      CRYPTO_set_dynlock_lock_callback(0);
      CRYPTO_set_dynlock_destroy_callback(0);
      for (int i = 0; i < CRYPTO_num_locks(); i++)
      {
         ::DeleteCriticalSection(&s_pLocks[i]);
      }
      free(s_pLocks);
      s_pLocks = 0;
   }
}
static void LockingCallback(
   int mode,
   int type,
   const char * /*file*/,
   int /*line*/)
{
   if (mode & CRYPTO_LOCK)
   {
      ::EnterCriticalSection(&s_pLocks[type]);
   }
   else
   {
      ::LeaveCriticalSection(&s_pLocks[type]);
   }
}
相关文章：