在單線程使用Threadsafe OpenSSL嗎？

Question

我已經完全重寫了這個問題，因為希望我可以通過這種方式獲得更多有用的答案。

我有一個帶有單個winsock2套接字的多線程客戶機/服務器應用程序，它用於“回撥”客戶機的唯一信息。 它是使用傳輸之前所有的套接字通信的與OpenSSL的加密SSL_write ，然后用解密SSL_read 。 我們在Socket包裝器類內部使用阻塞套接字和berkely風格的C調用，以使其成為面向對象的。 在單個線程中僅實例化了此Socket類的一個實例，並且對其的所有調用都在該單個線程中串行完成。 客戶端要“打電話回家”的服務器在Server 2008 R2機器上運行。 在從2000到7的所有版本的Windows中，客戶端都可以正常運行：它可以握手，獲取所需的信息並干凈地關閉連接。

在Windows 8中，客戶端在沒有說明的情況下使“電話回家”失敗，並使服務器處於嘗試不斷從套接字讀取更多信息的狀態。

一位同事向我建議的一件事是，確保將我的OpenSSL設置為線程安全的。

由於多種原因，我認為這是不必要的，但是我需要一個更明智的答案。
原因1：所有套接字I / O都在單個線程中發生。
原因2：所有套接字調用都以串行順序發生。
原因3：它適用於Windows 8之前的所有早期版本。

將OpenSSL設置為線程安全是否重要？

Answer 1

設置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 used\n"));
#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]);
   }
}