diff --cc src/network/ssl/qsslsocket_openssl.cpp
index 37a07c2,050fb1b..0000000
--- a/src/network/ssl/qsslsocket_openssl.cpp
+++ b/src/network/ssl/qsslsocket_openssl.cpp
@@@ -57,28 -57,14 +57,18 @@@
  #include <QtCore/qthread.h>
  #include <QtCore/qurl.h>
  #include <QtCore/qvarlengtharray.h>
- #include <QLibrary> // for loading the security lib for the CA store
  
 +QT_BEGIN_NAMESPACE
 +
- #if defined(Q_OS_MAC)
- #define kSecTrustSettingsDomainSystem 2 // so we do not need to include the header file
-     PtrSecCertificateGetData QSslSocketPrivate::ptrSecCertificateGetData = 0;
-     PtrSecTrustSettingsCopyCertificates QSslSocketPrivate::ptrSecTrustSettingsCopyCertificates = 0;
-     PtrSecTrustCopyAnchorCertificates QSslSocketPrivate::ptrSecTrustCopyAnchorCertificates = 0;
- #elif defined(Q_OS_WIN)
-     PtrCertOpenSystemStoreW QSslSocketPrivate::ptrCertOpenSystemStoreW = 0;
-     PtrCertFindCertificateInStore QSslSocketPrivate::ptrCertFindCertificateInStore = 0;
-     PtrCertCloseStore QSslSocketPrivate::ptrCertCloseStore = 0;
- #elif defined(Q_OS_SYMBIAN)
- #include <e32base.h>
- #include <e32std.h>
- #include <e32debug.h>
- #include <QtCore/private/qcore_symbian_p.h>
- #endif
++
+ static void initNetworkResources()
+ {
+     // Initialize resources
+     Q_INIT_RESOURCE(network);
+ }
  
 -QT_BEGIN_NAMESPACE
 +bool QSslSocketPrivate::s_libraryLoaded = false;
 +bool QSslSocketPrivate::s_loadedCiphersAndCerts = false;
  
  // Useful defines
  #define SSL_ERRORSTR() QString::fromLocal8Bit(q_ERR_error_string(q_ERR_get_error(), NULL))
@@@ -434,9 -402,13 +424,12 @@@ bool QSslSocketPrivate::ensureLibraryLo
  
      // Check if the library itself needs to be initialized.
      QMutexLocker locker(openssl_locks()->initLock());
 -    static int q_initialized = false;
 -    if (!q_initialized) {
 -        q_initialized = true;
 +    if (!s_libraryLoaded) {
 +        s_libraryLoaded = true;
  
+         // Initialize resources
+         initNetworkResources();
+ 
          // Initialize OpenSSL.
          q_CRYPTO_set_id_callback(id_function);
          q_CRYPTO_set_locking_callback(locking_function);
@@@ -476,68 -451,6 +469,33 @@@
      return true;
  }
  
 +void QSslSocketPrivate::ensureCiphersAndCertsLoaded()
 +{
 +    QMutexLocker locker(openssl_locks()->initLock());
 +    if (s_loadedCiphersAndCerts)
 +        return;
 +    s_loadedCiphersAndCerts = true;
 +
 +    resetDefaultCiphers();
 +
-     //load symbols needed to receive certificates from system store
- #if defined(Q_OS_MAC)
-     QLibrary securityLib("/System/Library/Frameworks/Security.framework/Versions/Current/Security");
-     if (securityLib.load()) {
-         ptrSecCertificateGetData = (PtrSecCertificateGetData) securityLib.resolve("SecCertificateGetData");
-         if (!ptrSecCertificateGetData)
-             qWarning("could not resolve symbols in security library"); // should never happen
- 
-         ptrSecTrustSettingsCopyCertificates = (PtrSecTrustSettingsCopyCertificates) securityLib.resolve("SecTrustSettingsCopyCertificates");
-         if (!ptrSecTrustSettingsCopyCertificates) { // method was introduced in Leopard, use legacy method if it's not there
-             ptrSecTrustCopyAnchorCertificates = (PtrSecTrustCopyAnchorCertificates) securityLib.resolve("SecTrustCopyAnchorCertificates");
-             if (!ptrSecTrustCopyAnchorCertificates)
-                 qWarning("could not resolve symbols in security library"); // should never happen
-         }
-     } else {
-         qWarning("could not load security library");
-     }
- #elif defined(Q_OS_WIN)
-     HINSTANCE hLib = LoadLibraryW(L"Crypt32");
-     if (hLib) {
- #if defined(Q_OS_WINCE)
-         ptrCertOpenSystemStoreW = (PtrCertOpenSystemStoreW)GetProcAddress(hLib, L"CertOpenStore");
-         ptrCertFindCertificateInStore = (PtrCertFindCertificateInStore)GetProcAddress(hLib, L"CertFindCertificateInStore");
-         ptrCertCloseStore = (PtrCertCloseStore)GetProcAddress(hLib, L"CertCloseStore");
- #else
-         ptrCertOpenSystemStoreW = (PtrCertOpenSystemStoreW)GetProcAddress(hLib, "CertOpenSystemStoreW");
-         ptrCertFindCertificateInStore = (PtrCertFindCertificateInStore)GetProcAddress(hLib, "CertFindCertificateInStore");
-         ptrCertCloseStore = (PtrCertCloseStore)GetProcAddress(hLib, "CertCloseStore");
- #endif
-         if (!ptrCertOpenSystemStoreW || !ptrCertFindCertificateInStore || !ptrCertCloseStore)
-             qWarning("could not resolve symbols in crypt32 library"); // should never happen
-     } else {
-         qWarning("could not load crypt32 library"); // should never happen
-     }
- #endif
 +    setDefaultCaCertificates(systemCaCertificates());
 +}
 +
 +/*!
 +    \internal
 +
 +    Declared static in QSslSocketPrivate, makes sure the SSL libraries have
 +    been initialized.
 +*/
 +
 +void QSslSocketPrivate::ensureInitialized()
 +{
 +    if (!supportsSsl())
 +        return;
 +
 +    ensureCiphersAndCertsLoaded();
 +}
 +
  /*!
      \internal
  
@@@ -571,228 -484,15 +529,151 @@@ void QSslSocketPrivate::resetDefaultCip
      setDefaultCiphers(ciphers);
  }
  
 +#if defined(Q_OS_SYMBIAN)
 +
 +CSymbianCertificateRetriever::CSymbianCertificateRetriever() : CActive(CActive::EPriorityStandard),
 +        iSequenceError(KErrNone)
 +{
 +}
 +
 +CSymbianCertificateRetriever::~CSymbianCertificateRetriever()
 +{
 +    iThread.Close();
 +}
 +
 +CSymbianCertificateRetriever* CSymbianCertificateRetriever::NewL()
 +{
 +    CSymbianCertificateRetriever* self = new (ELeave) CSymbianCertificateRetriever();
 +    CleanupStack::PushL(self);
 +    self->ConstructL();
 +    CleanupStack::Pop();
 +    return self;
 +}
 +
 +int CSymbianCertificateRetriever::GetCertificates(QList<QByteArray> &certificates)
 +{
 +    iCertificates = &certificates;
 +
 +    TRequestStatus status;
 +    iThread.Logon(status);
 +    iThread.Resume();
 +    User::WaitForRequest(status);
 +    if (iThread.ExitType() == EExitKill)
 +        return KErrDied;
 +    else
 +        return status.Int();    // Logon() completes with the thread's exit value
 +}
 +
 +void CSymbianCertificateRetriever::doThreadEntryL()
 +{
 +    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;
 +    CleanupStack::PushL(activeScheduler);
 +    CActiveScheduler::Install(activeScheduler);
 +
 +    CActiveScheduler::Add(this);
 +
 +    // These aren't deleted in the destructor so leaving the to CS is ok
 +    iCertStore = CUnifiedCertStore::NewLC(qt_s60GetRFs(), EFalse);
 +    iCertFilter = CCertAttributeFilter::NewLC();
 +
 +    // Kick off the sequence by initializing the cert store
 +    iState = Initializing;
 +    iCertStore->Initialize(iStatus);
 +    SetActive();
 +
 +    CActiveScheduler::Start();
 +
 +    // Sequence complete, clean up
 +
 +    // These MUST be cleaned up before the installed CActiveScheduler is destroyed and can't be left to the
 +    // destructor of CSymbianCertificateRetriever. Otherwise the destructor of CActiveScheduler will get
 +    // stuck.
 +    iCertInfos.Close();
 +    CleanupStack::PopAndDestroy(3);     // activeScheduler, iCertStore, iCertFilter
 +}
 +
 +
 +TInt CSymbianCertificateRetriever::ThreadEntryPoint(TAny* aParams)
 +{
 +    CTrapCleanup* cleanupStack = CTrapCleanup::New();
 +
 +    CSymbianCertificateRetriever* self = (CSymbianCertificateRetriever*) aParams;
 +    TRAPD(err, self->doThreadEntryL());
 +    delete cleanupStack;
 +
 +    // doThreadEntryL() can leave only before the retrieval sequence is started
 +    if (err)
 +        return err;
 +    else
 +        return self->iSequenceError;    // return any error that occured during the retrieval
 +}
 +
 +void CSymbianCertificateRetriever::ConstructL()
 +{
 +    User::LeaveIfError(iThread.Create(_L("CertWorkerThread"),
 +        CSymbianCertificateRetriever::ThreadEntryPoint, 16384, NULL, this));
 +}
 +
 +void CSymbianCertificateRetriever::DoCancel()
 +{
 +    // We never cancel the sequence
 +}
 +
 +TInt CSymbianCertificateRetriever::RunError(TInt aError)
 +{
 +    // If something goes wrong in the sequence, abort the sequence
 +    iSequenceError = aError;    // this gets reported to the client in the TRequestStatus
 +    CActiveScheduler::Stop();
 +    return KErrNone;
 +}
 +
 +void CSymbianCertificateRetriever::GetCertificateL()
 +{
 +    CCTCertInfo* certInfo = iCertInfos[iCurrentCertIndex];
 +    iCertificateData.resize(certInfo->Size());
 +    TPtr8 des((TUint8*)iCertificateData.data(), 0, iCertificateData.size());
 +    iCertStore->Retrieve(*certInfo, des, iStatus);
 +    iState = RetrievingCertificates;
 +    SetActive();
 +}
 +
 +void CSymbianCertificateRetriever::RunL()
 +{
 +    switch (iState) {
 +    case Initializing:
 +        iState = Listing;
 +        iCertStore->List(iCertInfos, *iCertFilter, iStatus);
 +        SetActive();
 +        break;
 +
 +    case Listing:
 +        iCurrentCertIndex = 0;
 +        GetCertificateL();
 +        break;
 +
 +    case RetrievingCertificates:
 +        iCertificates->append(iCertificateData);
 +        iCertificateData = QByteArray();
 +        iCurrentCertIndex++;
 +        if (iCurrentCertIndex < iCertInfos.Count())
 +            GetCertificateL();
 +        else
 +            // Stop the scheduler to return to the thread entry function
 +            CActiveScheduler::Stop();
 +        break;
 +    }
 +}
 +#endif // defined(Q_OS_SYMBIAN)
 +
  QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
  {
-     ensureInitialized();
-     QList<QSslCertificate> systemCerts;
- #if defined(Q_OS_MAC)
-     CFArrayRef cfCerts;
-     OSStatus status = 1;
- 
-     OSStatus SecCertificateGetData (
-        SecCertificateRef certificate,
-        CSSM_DATA_PTR data
-     );
- 
-     if (ptrSecCertificateGetData) {
-         if (ptrSecTrustSettingsCopyCertificates)
-             status = ptrSecTrustSettingsCopyCertificates(kSecTrustSettingsDomainSystem, &cfCerts);
-         else if (ptrSecTrustCopyAnchorCertificates)
-             status = ptrSecTrustCopyAnchorCertificates(&cfCerts);
-         if (!status) {
-             CFIndex size = CFArrayGetCount(cfCerts);
-             for (CFIndex i = 0; i < size; ++i) {
-                 SecCertificateRef cfCert = (SecCertificateRef)CFArrayGetValueAtIndex(cfCerts, i);
-                 CSSM_DATA data;
-                 CSSM_DATA_PTR dataPtr = &data;
-                 if (ptrSecCertificateGetData(cfCert, dataPtr)) {
-                     qWarning("error retrieving a CA certificate from the system store");
-                 } else {
-                     int len = data.Length;
-                     char *rawData = reinterpret_cast<char *>(data.Data);
-                     QByteArray rawCert(rawData, len);
-                     systemCerts.append(QSslCertificate::fromData(rawCert, QSsl::Der));
-                 }
-             }
-         }
-         else {
-            // no detailed error handling here
-            qWarning("could not retrieve system CA certificates");
-         }
-     }
- #elif defined(Q_OS_WIN)
-     if (ptrCertOpenSystemStoreW && ptrCertFindCertificateInStore && ptrCertCloseStore) {
-         HCERTSTORE hSystemStore;
- #if defined(Q_OS_WINCE)
-         hSystemStore = ptrCertOpenSystemStoreW(CERT_STORE_PROV_SYSTEM_W,
-                                                0,
-                                                0,
-                                                CERT_STORE_NO_CRYPT_RELEASE_FLAG|CERT_SYSTEM_STORE_CURRENT_USER,
-                                                L"ROOT");
- #else
-         hSystemStore = ptrCertOpenSystemStoreW(0, L"ROOT");
- #endif
-         if(hSystemStore) {
-             PCCERT_CONTEXT pc = NULL;
-             while(1) {
-                 pc = ptrCertFindCertificateInStore( hSystemStore, X509_ASN_ENCODING, 0, CERT_FIND_ANY, NULL, pc);
-                 if(!pc)
-                     break;
-                 QByteArray der((const char *)(pc->pbCertEncoded), static_cast<int>(pc->cbCertEncoded));
-                 QSslCertificate cert(der, QSsl::Der);
-                 systemCerts.append(cert);
-             }
-             ptrCertCloseStore(hSystemStore, 0);
-         }
-     }
- #elif defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/var/ssl/certs/*.pem"), QSsl::Pem, QRegExp::Wildcard)); // AIX
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/usr/local/ssl/certs/*.pem"), QSsl::Pem, QRegExp::Wildcard)); // Solaris
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/opt/openssl/certs/*.pem"), QSsl::Pem, QRegExp::Wildcard)); // HP-UX
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/etc/ssl/certs/*.pem"), QSsl::Pem, QRegExp::Wildcard)); // (K)ubuntu, OpenSUSE, Mandriva, ...
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/etc/pki/tls/certs/ca-bundle.crt"), QSsl::Pem)); // Fedora
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/usr/lib/ssl/certs/*.pem"), QSsl::Pem, QRegExp::Wildcard)); // Gentoo, Mandrake
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/usr/share/ssl/*.pem"), QSsl::Pem, QRegExp::Wildcard)); // Centos, Redhat, SuSE
-     systemCerts.append(QSslCertificate::fromPath(QLatin1String("/usr/local/ssl/*.pem"), QSsl::Pem, QRegExp::Wildcard)); // Normal OpenSSL Tarball
- #elif defined(Q_OS_SYMBIAN)
-     QList<QByteArray> certs;
-     QScopedPointer<CSymbianCertificateRetriever> retriever(CSymbianCertificateRetriever::NewL());
- 
-     retriever->GetCertificates(certs);
-     foreach (const QByteArray &encodedCert, certs) {
-         QSslCertificate cert(encodedCert, QSsl::Der);
-         if (!cert.isNull())
-             systemCerts.append(cert);
-     }
- #endif
+     // Qt provides a default bundle of certificates
+     QFile caBundle(QLatin1String(":/trolltech/network/ssl/qt-ca-bundle.crt"));
+     if (caBundle.open(QIODevice::ReadOnly | QIODevice::Text))
+         return QSslCertificate::fromDevice(&caBundle);
  
-     return systemCerts;
+     // Unreachable; return no bundle.
+     return QList<QSslCertificate>();
  }
  
  void QSslSocketBackendPrivate::startClientEncryption()
diff --cc src/network/ssl/qsslsocket_p.h
index 7d12c43,8e22664..0000000
--- a/src/network/ssl/qsslsocket_p.h
+++ b/src/network/ssl/qsslsocket_p.h
diff --git a/src/network/ssl/ssl.pri b/src/network/ssl/ssl.pri
index 8b2e2c1..5c96fa6 100644
--- a/src/network/ssl/ssl.pri
+++ b/src/network/ssl/ssl.pri
@@ -31,6 +31,8 @@ symbian {
                ssl/qsslsocket_openssl.cpp \
                ssl/qsslsocket_openssl_symbols.cpp
 
+    RESOURCES += network.qrc
+
     # Add optional SSL libs
     LIBS_PRIVATE += $$OPENSSL_LIBS
 }
