rhodes 6.2.0 → 7.5.1

data/platform/shared/net/HttpServer.cpp

@@ -24,6 +24,14 @@
 * http://rhomobile.com
 *------------------------------------------------------------------------*/
 
+#if defined(OS_ANDROID)
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <openssl/x509.h>
+#include <openssl/x509_vfy.h>
+#include <net/ssl.h>
+#endif
+
 #include "net/HttpServer.h"
 #include "common/RhodesApp.h"
 #include "common/RhoFilePath.h"
@@ -87,6 +95,19 @@ typedef unsigned __int16 uint16_t;
 
 #endif
 
+
+
+#ifdef OS_MACOSX
+#ifndef RHODES_EMULATOR
+
+extern "C" {
+    void rho_cocoa_server_stop();
+}
+
+#endif
+#endif
+
+
 #undef DEFAULT_LOGCATEGORY
 #define DEFAULT_LOGCATEGORY "HttpServer"
 
@@ -314,6 +335,88 @@ static VALUE create_request_hash(String const &application, String const &model,
 }
 #endif
 
+#ifdef OS_ANDROID
+
+void openss_trace_proc(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)
+{
+    std::string err_str;
+    err_str.assign((const char*)buf, len);
+    RAWLOG_INFO2(SSL_TAG "Openssl trace message: %s, content_type=%d", err_str.c_str(), content_type);
+}
+
+int openssl_verify_callback(int preverify_ok, X509_STORE_CTX* x509_ctx)
+{
+    int err = X509_STORE_CTX_get_error(x509_ctx);
+    RAWLOG_ERROR1(SSL_TAG "X509_STORE_CTX_get_error return: %d", err);
+    return preverify_ok;
+}
+
+void CHttpServer::close_ssl_socket(SSL* ssl_sock, int fd)
+{
+    int code = SSL_shutdown(ssl_sock);
+    int err = SSL_get_error(m_ssl_sock, code);
+
+    if (verbose) RAWLOG_ERROR3(SSL_TAG "Close ssl socket: %d, code=%d, err=%d", fd, code, err);
+
+    if (code >= 0)
+    {
+        SSL_free(ssl_sock);
+        closesocket(fd);
+        auto it = m_ssl_map.find(fd);
+        if (it != m_ssl_map.end())
+            m_ssl_map.erase(it);
+        else
+            RAWLOG_ERROR1(SSL_TAG "Unable erase ssl socket, sockfd=%d", fd);
+    }
+   
+}
+
+void CHttpServer::init_ssl()
+{
+    SSL_load_error_strings();	
+    OpenSSL_add_ssl_algorithms();
+
+    ssl_ctx = SSL_CTX_new(TLSv1_2_server_method());
+    if (!ssl_ctx) 
+    {
+        ssl_ctx = nullptr;
+        m_ssl_sock = nullptr;
+        RAWLOG_ERROR("Unable to create SSL context!");
+        return;
+    }
+
+    //const char* allowedCiphers = "AES256-SHA256:AES256-GCM-SHA384:AES128-GCM-SHA256:AES128-SHA256";
+    //SSL_CTX_set_cipher_list(ssl_ctx, allowedCiphers);
+    SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_TICKET);
+
+    SSL_CTX_set_tmp_dh(ssl_ctx, rho_get_RhoClassFactory()->createSSLEngine()->getDHparams());
+
+    if (SSL_CTX_use_certificate(ssl_ctx, (X509 *)rho_get_RhoClassFactory()->createSSLEngine()->getCertificate()) <= 0)
+    {
+        RAWLOG_ERROR("Unable set certificate!");
+        return;
+    }
+
+    if (SSL_CTX_use_PrivateKey(ssl_ctx, (EVP_PKEY*)rho_get_RhoClassFactory()->createSSLEngine()->getPrivateKey()) <= 0 ) 
+    {
+        RAWLOG_ERROR("Unable set private key!");
+        return;
+    }
+
+    SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, openssl_verify_callback);
+
+    X509_STORE* ssl_store = X509_STORE_new();
+    X509_STORE_add_cert(ssl_store, (X509*)rho_get_RhoClassFactory()->createSSLEngine()->getClientCertificate());
+    SSL_CTX_set_cert_store(ssl_ctx, ssl_store);
+    X509_STORE_set_trust(ssl_store, 1);
+    SSL_CTX_set_session_cache_mode(ssl_ctx, SSL_SESS_CACHE_OFF);
+
+    //SSL_CTX_set_msg_callback(ssl_ctx, openss_trace_proc);
+    
+}
+
+#endif
+
 CHttpServer::CHttpServer(int port, String const &root, String const &user_root, String const &runtime_root, bool enable_external_access, bool started_as_separated_simple_server)
     :m_active(false), m_port(port), verbose(true), m_IP_adress("")
 #ifdef OS_MACOSX
@@ -321,6 +424,7 @@ CHttpServer::CHttpServer(int port, String const &root, String const &user_root,
     , m_pQueue(0)    
 #endif
 {
+    //generator = rho_get_RhoClassFactory()->createNetRequestImpl();
     m_enable_external_access = enable_external_access;
     m_started_as_separated_simple_server = started_as_separated_simple_server;
     CHttpServer(port, root, user_root, runtime_root);
@@ -352,6 +456,19 @@ CHttpServer::CHttpServer(int port, String const &root, String const &user_root,
     m_strRhoUserRoot = m_userroot;
 	m_listener = INVALID_SOCKET;
 	m_sock = INVALID_SOCKET;
+
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+    m_generator = rho_conf_getInt("disable_external_access") ? rho_get_RhoClassFactory()->createSecurityTokenGenerator() : nullptr;
+    secureTokenExists = false;
+#endif
+
+#if defined(OS_ANDROID)
+    const char* value = get_app_build_config_item("local_https_server_with_client_checking");
+    if(value && !strcmp(value, "1"))
+    {
+        init_ssl();
+    }
+#endif
 }
     
 CHttpServer::CHttpServer(int port, String const &root)
@@ -375,6 +492,19 @@ CHttpServer::CHttpServer(int port, String const &root)
     m_strRhoUserRoot = m_root.substr(0, m_root.length()-5);
     m_listener = INVALID_SOCKET;
 	m_sock = INVALID_SOCKET;
+
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+    m_generator = rho_conf_getInt("disable_external_access") ? rho_get_RhoClassFactory()->createSecurityTokenGenerator() : nullptr;
+    secureTokenExists = false;
+#endif
+
+#if defined(OS_ANDROID)
+    const char* value = get_app_build_config_item("local_https_server_with_client_checking");
+    if(value && !strcmp(value, "1"))
+    {
+        init_ssl();
+    }
+#endif
 }
 
 CHttpServer::~CHttpServer()
@@ -394,6 +524,13 @@ void CHttpServer::close_listener()
 
 void CHttpServer::stop()
 {
+    
+#ifdef OS_MACOSX
+#ifndef RHODES_EMULATOR
+    rho_cocoa_server_stop();
+#endif
+#endif
+    
     // WARNING!!! It is not enough to just close listener on Android
     // to stop server. By unknown reason accept does not unblock if
     // it was closed in another thread. However, on iPhone it works
@@ -475,6 +612,10 @@ bool CHttpServer::init()
         close_listener();
         return false;
     }
+
+#if defined(OS_ANDROID)
+    signal(SIGPIPE, SIG_IGN);
+#endif
     
     struct sockaddr_in sa;
     memset(&sa, 0, sizeof(sa));
@@ -587,9 +728,33 @@ int CHttpServer::select_internal( SOCKET listener, fd_set& readfds )
     return ret;
 }
 
+#ifdef OS_ANDROID
+bool CHttpServer::accept_ssl_factory()
+{
+    if(SSL_in_init(m_ssl_sock) == 1)
+    {
+        int code = SSL_accept(m_ssl_sock);
+        int syscall_err = errno;
+        if (verbose) RAWLOG_ERROR2(SSL_TAG "SSL_accept return : %d, socket: %d", code, SSL_get_fd(m_ssl_sock));
+        if (code < 0)
+        {
+            char err_buff[255] = {};
+            int err = SSL_get_error(m_ssl_sock, code);
+            ERR_error_string(err, err_buff);
+            if (verbose) RAWLOG_ERROR3(SSL_TAG "SSL_accept error code: %d, socket: %d, errno: %d", err, SSL_get_fd(m_ssl_sock), syscall_err);
+            if (verbose) RAWLOG_ERROR1(SSL_TAG "SSL_accept error string: %s",  err_buff);
+            close_ssl_socket(m_ssl_sock, SSL_get_fd(m_ssl_sock));
+            return true;
+        }
+    }
+    
+    return false;
+}
+#endif
+
 bool CHttpServer::run()
 {
-    #ifdef OS_SAILFISH
+    #ifdef OS_LINUX
     pthread_t current_thread = pthread_self();
     struct sched_param params = { 0 };
     params.sched_priority = 9;
@@ -627,6 +792,10 @@ bool CHttpServer::run()
                 //RAWTRACE("After accept...");
                 if (!m_active) {
                     if (verbose) RAWTRACE("Stop HTTP server");
+                    if (conn != INVALID_SOCKET) {
+                        closesocket(conn);
+                        conn = INVALID_SOCKET;
+                    }
                     return true;
                 }
                 if (conn == INVALID_SOCKET) {
@@ -648,6 +817,26 @@ bool CHttpServer::run()
                 }
 #endif
                 m_sock = conn;
+#ifdef OS_ANDROID
+                if (ssl_ctx)
+                {
+                    ERR_clear_error();
+                    auto it = m_ssl_map.find(m_sock);
+                    if (it != m_ssl_map.end())
+                        m_ssl_sock = it->second;
+                    else
+                    {
+                        m_ssl_sock = SSL_new(ssl_ctx);
+                        m_ssl_map.emplace(m_sock, m_ssl_sock);
+                        SSL_set_fd(m_ssl_sock, m_sock);
+                    }
+
+                    if(accept_ssl_factory())                   
+                        continue;
+                }
+
+#endif
+
                 bProcessed = process(m_sock);
 #ifndef RHO_NO_RUBY_API
                 if (rho_ruby_is_started() && (!m_started_as_separated_simple_server))
@@ -657,7 +846,14 @@ bool CHttpServer::run()
                 }
 #endif
                 if (verbose) RAWTRACE("Close connected socket");
-                closesocket(m_sock);
+#ifdef OS_ANDROID
+                if(ssl_ctx)
+                {
+                    close_ssl_socket(m_ssl_sock, m_sock);
+                }
+                else 
+#endif
+                   closesocket(m_sock);
                 m_sock = INVALID_SOCKET;
             }
         }
@@ -679,7 +875,9 @@ bool CHttpServer::run()
                 if (verbose) {
                     LOG(INFO) + "GC Start.";
                 }
+                rho_ruby_gc_lock();
                 rb_gc();
+                rho_ruby_gc_release();
                 if (verbose) {
                     LOG(INFO) + "GC End.";
                 }
@@ -728,6 +926,15 @@ bool receive_request_test(ByteVector &request, int attempt)
 	return true;
 }
 
+int CHttpServer::internal_recv(char* buff, size_t size, int flags)
+{
+#ifdef OS_ANDROID
+    return ssl_ctx ? SSL_read(m_ssl_sock, buff, size) : recv(m_sock, buff, size, flags);
+#else
+    return recv(m_sock, buff, size, flags);
+#endif
+}
+
 bool CHttpServer::receive_request(ByteVector &request)
 {
 	if (verbose) RAWTRACE("Receiving request...");
@@ -737,7 +944,26 @@ bool CHttpServer::receive_request(ByteVector &request)
     int attempts = 0;
     for(;;) {
         if (verbose) RAWTRACE("Read portion of data from socket...");
-        int n = recv(m_sock, &buf[0], sizeof(buf), 0);
+
+        int n = internal_recv(&buf[0], sizeof(buf), 0);
+#ifdef OS_ANDROID
+        if(ssl_ctx && n < 0)
+        {
+            int err = SSL_get_error(m_ssl_sock, n);
+            if (verbose) RAWLOG_ERROR2(SSL_TAG "SSL_read return error code: %d, sock=%d", err, m_sock);
+            switch (err)
+            {
+            case SSL_ERROR_SSL:
+                return false;
+            case SSL_ERROR_WANT_READ:
+                break;
+            default:
+                break;
+            }
+        }
+#endif
+
+
         //RAWTRACE1("RECV: %d", n);
         if (n == -1) {
             int e = RHO_NET_ERROR_CODE;
@@ -801,6 +1027,15 @@ bool CHttpServer::receive_request(ByteVector &request)
     return true;
 }
 
+int CHttpServer::internal_send(const char* buff, size_t size, int flags)
+{
+#ifdef OS_ANDROID
+    return ssl_ctx ? SSL_write(m_ssl_sock, buff, size) : send(m_sock, buff, size, flags);
+#else
+    return send(m_sock, buff, size, flags);
+#endif
+}
+
 bool CHttpServer::send_response_impl(String const &data, bool continuation)
 {
 #ifdef OS_MACOSX
@@ -838,7 +1073,24 @@ bool CHttpServer::send_response_impl(String const &data, bool continuation)
     
     size_t pos = 0;
     for(; pos < data.size();) {
-        int n = send(m_sock, data.c_str() + pos, data.size() - pos, 0);
+
+        int n = internal_send(data.c_str() + pos, data.size() - pos, 0);
+#ifdef OS_ANDROID
+        if(ssl_ctx && n < 0)
+        {
+            int err = SSL_get_error(m_ssl_sock, n);
+            if(verbose) RAWLOG_ERROR2(SSL_TAG "SSL_write return error code: %d, sock=%d", err, m_sock);
+            switch (err)
+            {
+            case SSL_ERROR_SSL:
+                return false;
+            default:
+                break;
+            }
+        }
+#endif
+
+
         if (n == -1) {
             int e = RHO_NET_ERROR_CODE;
 #if !defined(WINDOWS_PLATFORM)
@@ -953,12 +1205,34 @@ bool CHttpServer::process(SOCKET sock)
     String method, uri, query;
     HeaderList headers;
     String body;
+#ifdef OS_ANDROID
+    if(ssl_ctx)
+    {
+        if(SSL_get_verify_result(m_ssl_sock) != X509_V_OK)
+        {
+           send_response(create_response("500 Internal Error"));        
+           return false;
+        }
+    }
+#endif
+
     if (!parse_request(method, uri, query, headers, body)) {
         if (verbose) RAWLOG_ERROR("Parsing error");
         send_response(create_response("500 Internal Error"));
         return false;
     }
 
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+    if(m_generator && !secureTokenExists)
+    {
+        if (verbose) RAWLOG_ERROR("Rhodes service is only accessible via Rhodes application.");
+        send_response(create_response("403 Forbidden: Rhodes service is only accessible via Rhodes application."));
+        return false;
+    }
+
+    secureTokenExists = false;
+#endif
+
     if ( !String_endsWith( uri, "js_api_entrypoint" ) )
         if (verbose) RAWLOG_INFO1("Process URI: '%s'", uri.c_str());
 
@@ -1012,6 +1286,12 @@ bool CHttpServer::parse_request(String &method, String &uri, String &query, Head
                 Header hdr;
                 if (!parse_header(line, hdr) || hdr.name.empty())
                     return false;
+
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+                if (m_generator && hdr.name == SECURITY_HEADER)
+                    secureTokenExists = hdr.value.find(m_generator->getSecurityToken()) != std::string::npos;
+#endif
+                
                 headers.push_back(hdr);
                 
                 String low;
@@ -1855,7 +2135,9 @@ bool CDirectHttpRequestQueue::run( )
         if ( bProcessed )
         {
           LOG(INFO) + "GC Start.";
+          rho_ruby_gc_lock();
           rb_gc();
+          rho_ruby_gc_release();
           LOG(INFO) + "GC End.";
         }
       }

data/platform/shared/net/HttpServer.h

@@ -32,6 +32,17 @@
 
 #include "common/RhoThread.h"
 
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+#include "common/ISecurityTokenGenerator.h"
+#endif
+
+#if defined(OS_ANDROID)
+#include <map>
+
+typedef struct ssl_st SSL;
+typedef struct ssl_ctx_st SSL_CTX;
+#endif
+
 #if !defined(WINDOWS_PLATFORM)
 typedef int SOCKET;
 #  define INVALID_SOCKET -1
@@ -47,6 +58,12 @@ typedef int SOCKET;
 #  define RHO_NET_ERROR_CODE ::WSAGetLastError()
 #endif
 
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_LINUX)
+#define SECURITY_HEADER "RHO-SECURE-TOKEN"
+#elif defined(OS_ANDROID)
+#define SECURITY_HEADER "User-Agent"
+#endif
+
 namespace rho
 {
 namespace net
@@ -184,6 +201,24 @@ private:
     bool m_enable_external_access;
     bool m_started_as_separated_simple_server;
 
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+    const rho::common::ISecurityTokenGenerator* m_generator;
+    bool secureTokenExists; 
+#endif
+
+    int internal_recv(char* buff, size_t size, int flags);
+    int internal_send(const char* buff, size_t size, int flags);
+#if defined(OS_ANDROID)
+#define SSL_TAG "SSL: "
+    SSL_CTX* ssl_ctx = nullptr;
+    SSL* m_ssl_sock = nullptr;
+    std::map<int, SSL*> m_ssl_map;
+
+    void init_ssl();
+    void close_ssl_socket(SSL* ssl_sock, int fd);
+    bool accept_ssl_factory();
+#endif
+
 #ifdef OS_MACOSX
     common::CMutex m_mxSyncRequest;
     ResponseWriter* m_localResponseWriter;

data/platform/shared/net/INetRequest.cpp

@@ -33,6 +33,7 @@
 
 #include "common/RhoConf.h"
 #include "logging/RhoLog.h"
+#include "common/ISecurityTokenGenerator.h"
 
 #undef DEFAULT_LOGCATEGORY
 #define DEFAULT_LOGCATEGORY "NetRequestTimer"
@@ -161,11 +162,44 @@ rho::net::CNetResponseWrapper CNetRequestWrapper::pullCookies(const String& strU
 
 rho::net::CNetResponseWrapper CNetRequestWrapper::doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders )
 {
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)  || defined(OS_LINUX)
+    const rho::common::ISecurityTokenGenerator* generator = rho_conf_getInt("disable_external_access") ?
+        rho_get_RhoClassFactory()->createSecurityTokenGenerator() : nullptr;
+
+    Hashtable<String,String> headers;
+    if(generator)
+    {
+        if(!pHeaders)
+            pHeaders = &headers;
+#if defined(OS_ANDROID)
+        pHeaders->insert(std::make_pair(SECURITY_HEADER, "RhodesAgent RHO-SECURE-TOKEN=" + generator->getSecurityToken()));
+#elif defined(OS_WINDOWS_DESKTOP) || defined(OS_LINUX)
+        pHeaders->insert(std::make_pair(SECURITY_HEADER, generator->getSecurityToken()));
+#endif
+    }
+#endif
     return m_pReqImpl->doRequest(method, strUrl, strBody, oSession, pHeaders );
 }
 
 rho::net::CNetResponseWrapper CNetRequestWrapper::pushMultipartData(const String& strUrl, VectorPtr<CMultipartItem*>& arItems, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+    const rho::common::ISecurityTokenGenerator* generator = rho_conf_getInt("disable_external_access") ? 
+       rho_get_RhoClassFactory()->createSecurityTokenGenerator() : nullptr;
+
+    Hashtable<String,String> headers;
+    if(generator)
+    {
+        if(!pHeaders)
+            pHeaders = &headers;
+#if defined(OS_ANDROID)
+        pHeaders->insert(std::make_pair(SECURITY_HEADER, "RhodesAgent RHO-SECURE-TOKEN=" + generator->getSecurityToken()));
+#elif defined(OS_WINDOWS_DESKTOP)
+        pHeaders->insert(std::make_pair(SECURITY_HEADER, generator->getSecurityToken()));
+#endif
+    }
+
+#endif
     return m_pReqImpl->pushMultipartData(strUrl, arItems, oSession, pHeaders);
 }
 
@@ -182,6 +216,12 @@ rho::net::CNetResponseWrapper CNetRequestWrapper::pushMultipartData(const String
 
 rho::net::CNetResponseWrapper CNetRequestWrapper::pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders,bool overwriteFile,bool createFolders, bool* pFileExistsFlag )
 {
+
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+    const rho::common::ISecurityTokenGenerator* generator = rho_conf_getInt("disable_external_access") ?
+        rho_get_RhoClassFactory()->createSecurityTokenGenerator() : nullptr;
+#endif
+
     if (!overwriteFile && common::CRhoFile::isFileExist(strFilePath.c_str())) {
         LOGC(WARNING,"Net") + "pullFile: " + strFilePath + " already exists, won't download since overwrite flag is not set";
         
@@ -213,6 +253,7 @@ rho::net::CNetResponseWrapper CNetRequestWrapper::pullFile(const String& strUrl,
     //don't request headers of will overwrite anyway
     if (!overwriteFile) {
         Hashtable<String, String> h;
+        
         ::getNetRequest().doRequest("HEAD", strUrl, "", oSession, &h );
     
         if ( h.containsKey("last-modified") )
@@ -242,6 +283,19 @@ rho::net::CNetResponseWrapper CNetRequestWrapper::pullFile(const String& strUrl,
         return m_pReqImpl->createEmptyNetResponse();
     }
     
+
+#if defined(OS_WINDOWS_DESKTOP) || defined(OS_ANDROID)
+    Hashtable<String,String> headers;
+    if(!pHeaders)
+        pHeaders = &headers;
+    if(generator)
+#if defined(OS_ANDROID)
+        pHeaders->insert(std::make_pair(SECURITY_HEADER, "RhodesAgent RHO-SECURE-TOKEN=" + generator->getSecurityToken()));
+#elif defined(OS_WINDOWS_DESKTOP)
+        pHeaders->insert(std::make_pair(SECURITY_HEADER, generator->getSecurityToken()));
+#endif
+
+#endif
     INetResponse* pResp = m_pReqImpl->pullFile( strUrl, tmpFile, oSession, pHeaders );
     
     tmpFile.close();

data/platform/shared/net/INetRequest.h

@@ -244,6 +244,12 @@ namespace common
 namespace net
 {
 
+class INetRequestBuilder
+{
+public:
+  virtual INetRequestImpl* build() = 0;
+};
+
 class INetRequestCallback
 {
   public:

data/platform/shared/net/linux/SSLImpl.cpp

@@ -28,7 +28,7 @@
 //#include <CFNetwork/CFNetwork.h>
 //#include <Security/Security.h>
 
-#include "sslimpl.h"
+#include "SSLImpl.h"
 
 #import "logging/RhoLog.h"
 #undef DEFAULT_LOGCATEGORY
@@ -58,6 +58,7 @@ namespace net
 void * SSLImpl::createStorage()
 {
     //return calloc(1, sizeof(ssl_data_t));
+    return NULL;
 }
 
 void SSLImpl::freeStorage(void *ptr)

data/platform/shared/net/ssl.h

@@ -34,6 +34,10 @@
 #define ssize_t int
 #endif
 
+typedef struct evp_pkey_st EVP_PKEY;
+typedef struct x509_st X509;
+typedef struct dh_st DH;
+
 namespace rho {
 namespace net {
 
@@ -49,6 +53,28 @@ struct ISSL
     virtual ssize_t send(const void *mem, size_t len, void *storage) = 0;
     virtual ssize_t recv(char *buf, size_t size, int *wouldblock, void *storage) = 0;
     virtual bool rand(unsigned char *entropy, size_t length) = 0;
+
+
+    virtual const EVP_PKEY* getPrivateKey() const
+    {
+        return nullptr;
+    }
+
+    virtual const X509* getCertificate() const
+    {
+        return nullptr;
+    }
+
+    virtual const X509* getClientCertificate() const
+    {
+        return nullptr;
+    }
+
+    virtual DH* getDHparams() const
+    {
+        return nullptr;
+    }
+
 };
 
 }

data/platform/shared/qt/RhoRubylib.pro

@@ -0,0 +1,10 @@
+CONFIG += c++14
+
+TEMPLATE = subdirs
+SUBDIRS = rubylib rholib sqlite3 syncengine
+
+CONFIG += ordered
+SUBDIRS += rhodes
+
+QMAKE_CXXFLAGS_RELEASE += -MP9
+QMAKE_CXXFLAGS_DEBUG += -MP9