rhodes 2.2.6 → 2.3.0.beta.1

data/platform/wm/rhodes/RhoCryptImpl.cpp

@@ -0,0 +1,248 @@
+#include "StdAfx.h"
+#include "RhoCryptImpl.h"
+#include "common/RhodesApp.h"
+
+namespace rho{
+namespace common{
+IMPLEMENT_LOGCLASS(CRhoCryptImpl,"RhoCrypt");
+#define checkError(func) _checkError(func, #func)
+
+CRhoCryptImpl::CRhoCryptImpl(void) : m_hCryptProv(0), m_hKey(0)
+{
+}
+
+CRhoCryptImpl::~CRhoCryptImpl(void)
+{
+    if ( m_hKey ) 
+        CryptDestroyKey(m_hKey);
+
+    if ( m_hCryptProv )
+        CryptReleaseContext( m_hCryptProv, 0 );
+}
+
+bool CRhoCryptImpl::_checkError( BOOL bRes, const char* szFunc )
+{
+    m_dwLastError = 0;
+    if ( !bRes )
+        m_dwLastError = GetLastError();
+
+    if ( m_dwLastError == 0 )
+        return true;
+
+    LPTSTR pszMessage = NULL;
+
+    DWORD dwLen = FormatMessage(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+        //FORMAT_MESSAGE_FROM_SYSTEM |
+        FORMAT_MESSAGE_FROM_HMODULE|
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+#if defined(_WIN32_WCE)
+        GetModuleHandle( _T("Coredll.dll") ),
+#else
+        GetModuleHandle( _T("Advapi32.dll") ),
+#endif
+        m_dwLastError,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        (LPTSTR)&pszMessage,
+        0, NULL );
+
+    LOG(ERROR) + szFunc + "failed with code: " + LOGFMT("0x%X") + m_dwLastError + ";Message: " + (pszMessage ? pszMessage : _T(""));
+    if ( pszMessage )
+        LocalFree(pszMessage);
+
+    return false;
+}
+
+void CRhoCryptImpl::readKeyFromStorage(DATA_BLOB& blobKey)
+{
+    StringW strKey = L"Software\\Rhomobile\\";
+    strKey += RHODESAPP().getAppNameW() + L"\\Storage\\" + m_strDBPartition;
+
+    CRegKey oKey;
+    LONG res = oKey.Open(HKEY_LOCAL_MACHINE, strKey.c_str(), KEY_READ);
+    if ( res != ERROR_SUCCESS )
+        return;
+
+    ULONG nBytes = 0;
+    res = oKey.QueryBinaryValue(L"DataKey", 0, &nBytes );
+    if ( res != ERROR_SUCCESS )
+        return;
+
+    blobKey.cbData = nBytes;
+    blobKey.pbData = (BYTE*)LocalAlloc(LMEM_FIXED, nBytes);
+    res = oKey.QueryBinaryValue(L"DataKey", blobKey.pbData, &nBytes );
+}
+
+void CRhoCryptImpl::saveKeyToStorage(DATA_BLOB& blobKey)
+{
+    LONG res = 0;
+    StringW strKey = L"Software\\Rhomobile\\";
+    strKey += RHODESAPP().getAppNameW() + L"\\Storage\\" + m_strDBPartition;
+
+    {
+        CRegKey oKey;
+        res = oKey.Create(HKEY_LOCAL_MACHINE, strKey.c_str() );
+    }
+
+    CRegKey oKey;
+    res = oKey.Open(HKEY_LOCAL_MACHINE, strKey.c_str(), KEY_WRITE);
+    if ( res != ERROR_SUCCESS )
+        return;
+
+    res = oKey.SetBinaryValue(L"DataKey", blobKey.pbData, blobKey.cbData );
+    if ( res != ERROR_SUCCESS )
+        return;
+}
+
+void CRhoCryptImpl::writeKeyToStorage()
+{
+    BYTE *pbKeyBlob = NULL;
+    DWORD dwBlobLen = 0;
+    if ( !checkError( CryptExportKey(m_hKey, 0, PLAINTEXTKEYBLOB, 0, NULL, &dwBlobLen)) )
+        return;
+
+    pbKeyBlob = (BYTE*)malloc(dwBlobLen);
+    checkError( CryptExportKey(m_hKey, 0, PLAINTEXTKEYBLOB, 0, pbKeyBlob, &dwBlobLen) );
+
+    DATA_BLOB unprotectedKey = {dwBlobLen , pbKeyBlob };
+    DATA_BLOB protectedKey = {0};
+    checkError( CryptProtectData( &unprotectedKey, L"Rhodes data key", 0, 0, 0, 0, &protectedKey ) );
+
+    if (pbKeyBlob)
+        free(pbKeyBlob);
+
+    saveKeyToStorage(protectedKey);
+
+    if ( protectedKey.pbData )
+        LocalFree(protectedKey.pbData);
+}
+
+void CRhoCryptImpl::initCryptProvider()
+{
+    if ( m_hCryptProv )
+        return;
+
+    LPCTSTR szContName = _T("RhodesKeyContainer");  // Name of the key container to be used.
+    checkError( CryptAcquireContext( &m_hCryptProv, szContName, NULL, PROV_RSA_AES, 0) ); 
+
+    if ( getErrorCode() == NTE_BAD_KEYSET )
+    {
+        checkError( CryptAcquireContext( &m_hCryptProv, szContName, NULL, PROV_RSA_AES, CRYPT_NEWKEYSET) );
+    }
+}
+
+void CRhoCryptImpl::initContext(const char* szPartition)
+{
+    if ( m_hCryptProv )
+        return;
+
+    convertToStringW(szPartition, m_strDBPartition);
+
+    initCryptProvider();
+    if ( getErrorCode() != 0 )
+        return;
+
+    DATA_BLOB protectedKey = {0};
+    readKeyFromStorage(protectedKey);
+    if ( protectedKey.cbData > 0 )
+    {
+        DATA_BLOB unprotectedKey = {0};
+        LPWSTR pDescr =  NULL;
+        checkError(CryptUnprotectData( &protectedKey, &pDescr, NULL, NULL, NULL, 0, &unprotectedKey));
+
+        checkError(CryptImportKey(m_hCryptProv, unprotectedKey.pbData, unprotectedKey.cbData, 0, 0, &m_hKey));
+
+        if( pDescr )
+            LocalFree(pDescr);
+        if ( unprotectedKey.pbData )
+            LocalFree(unprotectedKey.pbData);
+        if ( protectedKey.pbData )
+            LocalFree(protectedKey.pbData);
+    }else
+    {  
+        //generate new key
+        if ( checkError(CryptGenKey(m_hCryptProv, CALG_RC4, CRYPT_EXPORTABLE, &m_hKey)) )
+        {
+            //DWORD dwPadding = ZERO_PADDING;
+            //checkError( CryptSetKeyParam( m_hKey, KP_PADDING, (const BYTE*)&dwPadding, 0) ); 
+
+            writeKeyToStorage();
+        }
+    }
+}
+
+int CRhoCryptImpl::db_encrypt( const char* szPartition, int size, unsigned char* data, unsigned char* dataOut )
+{
+    initContext(szPartition);
+
+    memcpy(dataOut, data, size);
+
+    DWORD dwSize = size;
+    if ( m_hKey )
+    {
+        checkError( CryptEncrypt( m_hKey,
+                0,               // No hashing of data
+                TRUE,            // Final or only buffer of data
+                0,               // Must be zero
+                dataOut,             // Data buffer
+                &dwSize,         // Size of data
+                dwSize           // Size of block
+        ));         
+    }
+
+    return getErrorCode() == 0 ? 1 : 0;
+}
+
+int CRhoCryptImpl::db_decrypt( const char* szPartition, int size, unsigned char* data )
+{
+    initContext(szPartition);
+
+    DWORD dwSize = size;
+
+    if ( m_hKey )
+    {
+        checkError( CryptDecrypt( m_hKey,
+                0,               // No hashing of data
+                TRUE,            // Final or only buffer of data
+                0,               // Must be zero
+                data,             // Data buffer
+                &dwSize         // Size of data
+        ));         
+    }
+
+    return getErrorCode() == 0 ? 1 : 0;
+}
+
+int CRhoCryptImpl::set_db_CryptKey( const char* szPartition, const char* szKey, bool bPersistent )
+{
+    convertToStringW(szPartition, m_strDBPartition);
+
+    int dwBlobLen = rho_base64_decode( szKey, -1, 0 );
+    BYTE* pbKeyBlob = (BYTE*)malloc(dwBlobLen);
+    rho_base64_decode(szKey, -1, (char*)pbKeyBlob);
+
+    DATA_BLOB unprotectedKey = {dwBlobLen , pbKeyBlob };
+
+    if ( !bPersistent )
+    {
+        initCryptProvider();
+        checkError(CryptImportKey(m_hCryptProv, unprotectedKey.pbData, unprotectedKey.cbData, 0, 0, &m_hKey));
+    }else
+    {
+        DATA_BLOB protectedKey = {0};
+        checkError( CryptProtectData( &unprotectedKey, L"Rhodes data key", 0, 0, 0, 0, &protectedKey ) );
+
+        if (pbKeyBlob)
+            free(pbKeyBlob);
+
+        saveKeyToStorage(protectedKey);
+
+        if ( protectedKey.pbData )
+            LocalFree(protectedKey.pbData);
+    }
+
+    return 1;
+}
+
+}
+}

data/platform/wm/rhodes/RhoCryptImpl.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "logging/RhoLog.h"
+#include "common/IRhoCrypt.h"
+
+#include <wincrypt.h>
+
+namespace rho{
+namespace common{
+
+class CRhoCryptImpl : public IRhoCrypt
+{
+    DEFINE_LOGCLASS;
+
+    HCRYPTPROV m_hCryptProv;
+    HCRYPTKEY  m_hKey;
+    DWORD      m_dwLastError;
+    StringW    m_strDBPartition;
+
+public:
+    CRhoCryptImpl(void);
+    ~CRhoCryptImpl(void);
+
+    virtual int db_decrypt( const char* szPartition, int size, unsigned char* data );
+    virtual int db_encrypt( const char* szPartition, int size, unsigned char* data, unsigned char* dataOut );
+    virtual int set_db_CryptKey( const char* szPartition, const char* szKey, bool bPersistent );
+private:
+    bool _checkError( BOOL bRes, const char* szFunc );
+    unsigned int getErrorCode(){ return m_dwLastError; }
+
+    void initContext(const char* szPartition);
+    void initCryptProvider();
+
+    void readKeyFromStorage(DATA_BLOB& blobKey);
+    void writeKeyToStorage();
+    void saveKeyToStorage(DATA_BLOB& blobKey);
+};
+
+}
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+void rho_crypt_aes_256_encrypt(int size, unsigned char *in, unsigned char *out);
+void rho_crypt_aes_256_decrypt(int size, unsigned char *in, unsigned char *out);
+
+#ifdef __cplusplus
+};
+#endif //__cplusplus

data/platform/wm/rhodes/RhoNativeViewManager.cpp

@@ -18,6 +18,8 @@
 
 extern "C" HWND getWebViewWnd();
 extern "C" HWND getMainWnd();
+CMainWindow* Rhodes_getMainWindow();
+
 
 class RhoNativeViewHolder{
   public :
@@ -43,7 +45,65 @@ class RhoNativeViewHolder{
 	RhoNativeViewHolder* next;
 };
 
+static int ourGlobalID = 1;
+
+class RhoOpenedNativeView {
+public:
+	RhoOpenedNativeView() {
+		next = NULL;
+		id = ourGlobalID++;
+		tab_index = 0;
+		factory_holder = NULL;
+		n_view = NULL;
+	}
+	RhoOpenedNativeView* next;
+	int id;
+	int tab_index;
+	RhoNativeViewHolder* factory_holder;
+	NativeView* n_view;
+};
+
+
+class RhoNativeViewRunnable_OpenViewCommand : public RhoNativeViewRunnable {
+public:
+	RhoNativeViewRunnable_OpenViewCommand(RhoOpenedNativeView* view) {
+		mView = view;
+	}
+	virtual void run() {
+		CMainWindow* mw = Rhodes_getMainWindow();
+		String sn(mView->factory_holder->viewtype);
+		mw->openNativeView(mView->factory_holder->factory, mView->n_view, sn);
+		//delete this;
+	}
+
+private:
+	RhoOpenedNativeView* mView;
+};
+
+class RhoNativeViewRunnable_CloseViewCommand : public RhoNativeViewRunnable {
+public:
+	RhoNativeViewRunnable_CloseViewCommand() {
+	}
+	virtual void run() {
+		CMainWindow* mw = Rhodes_getMainWindow();
+		mw->closeNativeView();
+		//delete this;
+	}
+};
+
+
+
+
+
 static RhoNativeViewHolder* first = NULL;
+static RhoOpenedNativeView* first_opened = NULL;
+
+
+
+
+
+
+
 
 
 static void addRhoNativeViewHolder(RhoNativeViewHolder* holder) {
@@ -76,6 +136,8 @@ static void removeRhoNativeViewHolder(RhoNativeViewHolder* holder) {
 	}
 }
 
+
+
 static RhoNativeViewHolder* getHolderByViewTypeName(const char* name) {
 	RhoNativeViewHolder* p = first;
 	while (p != NULL) {
@@ -88,6 +150,76 @@ static RhoNativeViewHolder* getHolderByViewTypeName(const char* name) {
 }
 
 
+
+
+
+
+
+static void addRhoNativeOpenedView(RhoOpenedNativeView* view) {
+	if (first_opened == NULL) {
+		first_opened = view;
+		view->next = NULL;
+	}
+	else {
+		view->next = first_opened;
+		first_opened = view;
+	}
+}
+
+static void removeRhoNativeOpenedView(RhoOpenedNativeView* view) {
+	RhoOpenedNativeView* p = first_opened;
+	RhoOpenedNativeView* prev = NULL;
+	while (p != NULL) {
+		if (p == view) {
+			RhoOpenedNativeView* next = p->next;
+			if (prev != NULL) {
+				prev->next = next;
+			}
+			if (first_opened == p) {
+				first_opened = NULL;
+			}
+			delete p;
+		}
+		prev = p;
+		p = p->next;
+	}
+}
+
+
+
+static RhoOpenedNativeView* getOpenedViewByID(int v_id) {
+	RhoOpenedNativeView* p = first_opened;
+	while (p != NULL) {
+		if (p->id == v_id) {
+			return p;
+		}
+		p = p->next;
+	}
+	return NULL;
+}
+
+
+static RhoOpenedNativeView* getOpenedViewByNativeView(NativeView* nv) {
+	RhoOpenedNativeView* p = first_opened;
+	while (p != NULL) {
+		if (p->n_view == nv) {
+			return p;
+		}
+		p = p->next;
+	}
+	return NULL;
+}
+
+
+
+
+
+
+
+
+
+
+
 void RhoNativeViewManager::registerViewType(const char* viewType, NativeViewFactory* factory) {
 	RhoNativeViewHolder* holder = new RhoNativeViewHolder();
 	holder->factory = factory;
@@ -124,3 +256,79 @@ void RhoNativeViewUtil::executeInUIThread_WM(RhoNativeViewRunnable* command) {
 	::PostMessage(main_wnd, WM_EXECUTE_COMMAND, (WPARAM)command, 0);
 
 }
+
+
+extern "C" int rho_native_view_manager_create_native_view(const char* viewtype, int tab_index, VALUE params) {
+	RhoNativeViewHolder* h = getHolderByViewTypeName(viewtype);
+	if (h == NULL) {
+		return -1;
+	}
+	NativeViewFactory* factory = h->factory;
+	NativeView* nv = factory->getNativeView(viewtype);
+	if (nv == NULL) {
+		return -1;
+	}
+	//String vtype = new String(viewtype);
+	
+	RhoOpenedNativeView* opened_view = new RhoOpenedNativeView();
+	opened_view->factory_holder = h;
+	opened_view->n_view = nv;
+	opened_view->tab_index = tab_index;
+
+	addRhoNativeOpenedView(opened_view);
+
+	RhoNativeViewRunnable_OpenViewCommand* open_command = new RhoNativeViewRunnable_OpenViewCommand(opened_view);
+
+	RhoNativeViewUtil::executeInUIThread_WM(open_command);
+
+	return opened_view->id;
+}
+
+extern "C" void rho_native_view_manager_navigate_native_view(int native_view_id, const char* url) {
+	RhoOpenedNativeView* opened_view = getOpenedViewByID(native_view_id);
+	if (opened_view != NULL) {
+		opened_view->n_view->navigate(url);
+	}
+}
+
+extern "C" void rho_native_view_manager_destroy_native_view(int native_view_id) {
+	RhoOpenedNativeView* opened_view = getOpenedViewByID(native_view_id);
+	if (opened_view != NULL) {
+		removeRhoNativeOpenedView(opened_view);
+		RhoNativeViewRunnable_CloseViewCommand* close_command = new RhoNativeViewRunnable_CloseViewCommand();
+		RhoNativeViewUtil::executeInUIThread_WM(close_command);
+	}
+}
+
+
+
+
+// destroy native view (opened with URL prefix or in separated full-screen window)
+// this function can executed from your native code (from NativeView code, for example)
+// instead of this function you can execute destroy() for Ruby NativeView object
+void RhoNativeViewManager::destroyNativeView(NativeView* nativeView) {
+	RhoOpenedNativeView* opened_view = getOpenedViewByNativeView(nativeView);
+	if (opened_view != NULL) {
+		RhoNativeViewRunnable_CloseViewCommand* close_command = new RhoNativeViewRunnable_CloseViewCommand();
+		RhoNativeViewUtil::executeInUIThread_WM(close_command);
+	}
+}
+
+int RhoNativeViewManager::openNativeView(const char* viewType, int tab_index, VALUE params) {
+	return rho_native_view_manager_create_native_view(viewType, tab_index, params);
+}
+
+
+void RhoNativeViewManager::closeNativeView(int v_id) {
+	rho_native_view_manager_destroy_native_view(v_id);
+}
+
+
+
+
+
+
+
+
+
+