diff --git a/net.h b/net.h
index a0b2929daa..5995ac3343 100644
--- a/net.h
+++ b/net.h
@@ -604,7 +604,7 @@ public:
 
     void BeginMessage(const char* pszCommand)
     {
-        EnterCriticalSection(&cs_vSend);
+        cs_vSend.Enter();
         if (nPushPos != -1)
             AbortMessage();
         nPushPos = vSend.size();
@@ -618,7 +618,7 @@ public:
             return;
         vSend.resize(nPushPos);
         nPushPos = -1;
-        LeaveCriticalSection(&cs_vSend);
+        cs_vSend.Leave();
         printf("(aborted)\n");
     }
 
@@ -643,7 +643,7 @@ public:
         printf("\n");
 
         nPushPos = -1;
-        LeaveCriticalSection(&cs_vSend);
+        cs_vSend.Leave();
     }
 
     void EndMessageAbortIfEmpty()
diff --git a/util.cpp b/util.cpp
index 6ba84a516d..bdf899d78e 100644
--- a/util.cpp
+++ b/util.cpp
@@ -13,14 +13,14 @@ bool fPrintToConsole = false;
 
 
 // Init openssl library multithreading support
-static HANDLE* lock_cs;
+static wxMutex** ppmutexOpenSSL;
 
-void win32_locking_callback(int mode, int type, const char* file, int line)
+void win32_locking_callback(int mode, int i, const char* file, int line)
 {
     if (mode & CRYPTO_LOCK)
-        WaitForSingleObject(lock_cs[type], INFINITE);
+        ppmutexOpenSSL[i]->Lock();
     else
-        ReleaseMutex(lock_cs[type]);
+        ppmutexOpenSSL[i]->Unlock();
 }
 
 // Init
@@ -30,9 +30,9 @@ public:
     CInit()
     {
         // Init openssl library multithreading support
-        lock_cs = (HANDLE*)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(HANDLE));
+        ppmutexOpenSSL = (wxMutex**)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(wxMutex*));
         for (int i = 0; i < CRYPTO_num_locks(); i++)
-            lock_cs[i] = CreateMutex(NULL,FALSE,NULL);
+            ppmutexOpenSSL[i] = new wxMutex();
         CRYPTO_set_locking_callback(win32_locking_callback);
 
         // Seed random number generator with screen scrape and other hardware sources
@@ -46,8 +46,8 @@ public:
         // Shutdown openssl library multithreading support
         CRYPTO_set_locking_callback(NULL);
         for (int i =0 ; i < CRYPTO_num_locks(); i++)
-            CloseHandle(lock_cs[i]);
-        OPENSSL_free(lock_cs);
+            delete ppmutexOpenSSL[i];
+        OPENSSL_free(ppmutexOpenSSL);
     }
 }
 instance_of_cinit;
@@ -55,6 +55,10 @@ instance_of_cinit;
 
 
 
+
+
+
+
 void RandAddSeed()
 {
     // Seed with CPU performance counter
diff --git a/util.h b/util.h
index 61f774a8d9..436281c90a 100644
--- a/util.h
+++ b/util.h
@@ -106,28 +106,38 @@ void AddTimeData(unsigned int ip, int64 nTime);
 // Could use wxCriticalSection for portability, but it doesn't support TryEnterCriticalSection
 class CCriticalSection
 {
+#ifdef __WXMSW__
 protected:
     CRITICAL_SECTION cs;
 public:
-    char* pszFile;
-    int nLine;
     explicit CCriticalSection() { InitializeCriticalSection(&cs); }
     ~CCriticalSection() { DeleteCriticalSection(&cs); }
     void Enter() { EnterCriticalSection(&cs); }
     void Leave() { LeaveCriticalSection(&cs); }
     bool TryEnter() { return TryEnterCriticalSection(&cs); }
-    CRITICAL_SECTION* operator&() { return &cs; }
+#else
+protected:
+    wxMutex mutex;
+public:
+    explicit CCriticalSection() { }
+    ~CCriticalSection() { }
+    void Enter() { mutex.Lock(); }
+    void Leave() { mutex.Unlock(); }
+    bool TryEnter() { return mutex.TryLock() == wxMUTEX_NO_ERROR; }
+#endif
+public:
+    char* pszFile;
+    int nLine;
 };
 
 // Automatically leave critical section when leaving block, needed for exception safety
 class CCriticalBlock
 {
 protected:
-    CRITICAL_SECTION* pcs;
+    CCriticalSection* pcs;
 public:
-    CCriticalBlock(CRITICAL_SECTION& csIn) { pcs = &csIn; EnterCriticalSection(pcs); }
-    CCriticalBlock(CCriticalSection& csIn) { pcs = &csIn; EnterCriticalSection(pcs); }
-    ~CCriticalBlock() { LeaveCriticalSection(pcs); }
+    CCriticalBlock(CCriticalSection& csIn) { pcs = &csIn; pcs->Enter(); }
+    ~CCriticalBlock() { pcs->Leave(); }
 };
 
 // WARNING: This will catch continue and break!
@@ -141,11 +151,10 @@ public:
 class CTryCriticalBlock
 {
 protected:
-    CRITICAL_SECTION* pcs;
+    CCriticalSection* pcs;
 public:
-    CTryCriticalBlock(CRITICAL_SECTION& csIn) { pcs = (TryEnterCriticalSection(&csIn) ? &csIn : NULL); }
-    CTryCriticalBlock(CCriticalSection& csIn) { pcs = (TryEnterCriticalSection(&csIn) ? &csIn : NULL); }
-    ~CTryCriticalBlock() { if (pcs) LeaveCriticalSection(pcs); }
+    CTryCriticalBlock(CCriticalSection& csIn) { pcs = (csIn.TryEnter() ? &csIn : NULL); }
+    ~CTryCriticalBlock() { if (pcs) pcs->Leave(); }
     bool Entered() { return pcs != NULL; }
 };