tor-browser

main.cpp (6798B)

---

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0.If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include <windows.h>
#include "resource.h"
#include "WebBrowser.h"
#include "exdll.h"

// These variables are global because they're needed by more than one of
// our plugin methods. The expectation is that these are safe because the
// NSIS framework doesn't really support more than one dialog or thread
// at a time, and that means we don't have to either.

// Instance handle for this DLL
HINSTANCE gHInst = nullptr;
// Parent window proc which we'll need to override and then restore
WNDPROC gWndProcOld = nullptr;
// Handle to the dialog we'll create
HWND gHwnd = nullptr;
// Set to true when our dialog should be destroyed
bool gDone = false;
// Web browser OLE site
WebBrowser* gBrowser = nullptr;

// Set web browser control feature flags that are configured on a per-process
// basis, not for individual instances of the control. This mainly means
// disabling things that could turn into security holes.
static void ConfigurePerProcessBrowserFeatures() {
 // For most of the features we're configuring, setting them to TRUE means
 // we're disabling something, but for a few setting them to FALSE disables the
 // thing. We don't necessarily care about *every* feature that's in the
 // INTERNETFEATURELIST enum, but it seems safer to set them all anyway, to
 // make sure we don't miss anything we *do* care about.
 struct Feature {
   INTERNETFEATURELIST id;
   BOOL value;
 } features[] = {{FEATURE_OBJECT_CACHING, TRUE},
                 {FEATURE_ZONE_ELEVATION, TRUE},
                 {FEATURE_MIME_HANDLING, TRUE},
                 {FEATURE_MIME_SNIFFING, FALSE},
                 {FEATURE_WINDOW_RESTRICTIONS, TRUE},
                 {FEATURE_WEBOC_POPUPMANAGEMENT, TRUE},
                 {FEATURE_BEHAVIORS, TRUE},
                 {FEATURE_DISABLE_MK_PROTOCOL, TRUE},
                 // It isn't possible to set FEATURE_LOCALMACHINE_LOCKDOWN
                 // using the SET_FEATURE_ON_PROCESS mode; see the MSDN page
                 // on CoInternetSetFeatureEnabled for the explanation.
                 //{FEATURE_LOCALMACHINE_LOCKDOWN, TRUE},
                 {FEATURE_SECURITYBAND, FALSE},
                 {FEATURE_RESTRICT_ACTIVEXINSTALL, TRUE},
                 {FEATURE_VALIDATE_NAVIGATE_URL, TRUE},
                 {FEATURE_RESTRICT_FILEDOWNLOAD, TRUE},
                 {FEATURE_ADDON_MANAGEMENT, TRUE},
                 {FEATURE_PROTOCOL_LOCKDOWN, TRUE},
                 {FEATURE_HTTP_USERNAME_PASSWORD_DISABLE, TRUE},
                 {FEATURE_SAFE_BINDTOOBJECT, TRUE},
                 {FEATURE_UNC_SAVEDFILECHECK, TRUE},
                 {FEATURE_GET_URL_DOM_FILEPATH_UNENCODED, FALSE},
                 {FEATURE_TABBED_BROWSING, FALSE},
                 {FEATURE_SSLUX, FALSE},
                 {FEATURE_DISABLE_NAVIGATION_SOUNDS, TRUE},
                 {FEATURE_DISABLE_LEGACY_COMPRESSION, TRUE},
                 {FEATURE_FORCE_ADDR_AND_STATUS, FALSE},
                 {FEATURE_XMLHTTP, FALSE},
                 {FEATURE_DISABLE_TELNET_PROTOCOL, TRUE},
                 {FEATURE_FEEDS, FALSE},
                 {FEATURE_BLOCK_INPUT_PROMPTS, TRUE}};

 for (Feature feature : features) {
   CoInternetSetFeatureEnabled(feature.id, SET_FEATURE_ON_PROCESS,
                               feature.value);
 }
}

BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID) {
 if (reason == DLL_PROCESS_ATTACH) {
   gHInst = instance;
   (void)OleInitialize(nullptr);
   ConfigurePerProcessBrowserFeatures();
 }
 return TRUE;
}

UINT_PTR __cdecl NSISPluginCallback(NSPIM msg) {
 if (msg == NSPIM_UNLOAD) {
   OleUninitialize();
 }
 return 0;
}

BOOL CALLBACK ParentWndProc(HWND hwnd, UINT message, WPARAM wParam,
                           LPARAM lParam) {
 BOOL bRes =
     CallWindowProc((WNDPROC)gWndProcOld, hwnd, message, wParam, lParam);
 if (!bRes && message == WM_NOTIFY_OUTER_NEXT) {
   gDone = true;
   PostMessage(gHwnd, WM_CLOSE, 0, 0);
 }
 return bRes;
}

BOOL CALLBACK DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
 return FALSE;
}

void Init(HWND hWndParent, int string_size, TCHAR* variables,
         stack_t** stacktop, extra_parameters* extra) {
 EXDLL_INIT();
 extra->RegisterPluginCallback(gHInst, NSISPluginCallback);

 HWND hwndChild = GetDlgItem(hWndParent, 1018);
 if (!hwndChild) {
   return;
 }

 HWND hwnd =
     CreateDialog(gHInst, MAKEINTRESOURCE(IDD_DIALOG1), hWndParent, DlgProc);
 if (!hwnd) {
   gDone = true;
 } else {
   gDone = false;
   gWndProcOld =
       (WNDPROC)SetWindowLong(hWndParent, DWL_DLGPROC, (LONG)ParentWndProc);

   // Tell NSIS to replace its inner dialog with ours.
   SendMessage(hWndParent, WM_NOTIFY_CUSTOM_READY, (WPARAM)hwnd, 0);

   // Initialize the browser control.
   if (gBrowser) {
     gBrowser->Shutdown();
     gBrowser->Release();
   }
   gBrowser = new WebBrowser(hwnd);

   if (!gBrowser || !gBrowser->IsInitialized()) {
     return;
   }

   gHwnd = hwnd;

   // Move our dialog to match the size of the parent.
   RECT r;
   GetClientRect(hwndChild, &r);
   MoveWindow(hwnd, r.left, r.top, r.right - r.left, r.bottom - r.top, FALSE);
   gBrowser->SetRect(r);
 }
}

PLUGINFUNCTION(ShowPage) {
 if (!gBrowser) {
   Init(hWndParent, string_size, variables, stacktop, extra);
 }

 if (!gBrowser->IsInitialized()) {
   return;
 }

 TCHAR* sUrl =
     (TCHAR*)HeapAlloc(GetProcessHeap(), 0, g_stringsize * sizeof(TCHAR));
 popstring(sUrl);

 if (gBrowser) {
   gBrowser->Navigate(sUrl);

   ShowWindow(gHwnd, SW_SHOWNA);
   UpdateWindow(gHwnd);

   while (!gDone) {
     // This explicit wait call is needed rather than just a blocking
     // GetMessage because we need this thread to be alertable so that our
     // timers can wake it up and run their callbacks.
     MsgWaitForMultipleObjectsEx(0, nullptr, 100, QS_ALLINPUT,
                                 MWMO_ALERTABLE | MWMO_INPUTAVAILABLE);
     MSG msg;
     if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
       bool tab = msg.message == WM_KEYDOWN && msg.wParam == VK_TAB;

       if (gBrowser->ActiveObjectTranslateAccelerator(tab, &msg) != S_OK &&
           !IsDialogMessage(gHwnd, &msg) &&
           !IsDialogMessage(g_hwndParent, &msg)) {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
       }
     }
   }

   SetWindowLong(g_hwndParent, DWL_DLGPROC, (LONG)gWndProcOld);
   if (gHwnd) {
     DestroyWindow(gHwnd);
   }

   gBrowser->Shutdown();
   gBrowser->Release();
   gBrowser = nullptr;
 }

 HeapFree(GetProcessHeap(), 0, (char*)sUrl);
}