Issue 1793 - check whether the frame is whitelisted before injecting CSS

src/plugin/AdblockPlusClient.cpp

+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2015 Eyeo GmbH
+ *
+ * Adblock Plus is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Adblock Plus is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "PluginStdAfx.h"
+#include "AdblockPlusClient.h"
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginFilter.h"
-#include "PluginClientFactory.h"
 #include "PluginMutex.h"
 #include "PluginClass.h"
-
-#include "AdblockPlusClient.h"
-
 #include "../shared/Utils.h"
 
 namespace
 {
+  class ScopedProcessInformation : public PROCESS_INFORMATION {
+  public:
+    ScopedProcessInformation()
+    {
+      hProcess = hThread = 0;
+      dwProcessId = dwThreadId = 0;
+    }
+    ~ScopedProcessInformation()
+    {
+      if (hThread != nullptr)
+      {
+        CloseHandle(hThread);
+      }
+      if (hProcess != nullptr)
+      {
+        CloseHandle(hProcess);
+      }
+    }
+  };
+
   void SpawnAdblockPlusEngine()
   {
     std::wstring engineExecutablePath = GetDllDir() + L"AdblockPlusEngine.exe";
-    CString params = to_CString(L"AdblockPlusEngine.exe " + GetBrowserLanguage());
+    std::wstring params = L"AdblockPlusEngine.exe " + GetBrowserLanguage();
 
     STARTUPINFO startupInfo = {};
-    PROCESS_INFORMATION processInformation = {};
-
-    HANDLE token;
-    OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE | TOKEN_ADJUST_DEFAULT | TOKEN_QUERY | TOKEN_ASSIGN_PRIMARY, &token);
-
-    TOKEN_APPCONTAINER_INFORMATION *acs = NULL;
-    DWORD length = 0;
-
-    // Get AppContainer SID
-    if (!GetTokenInformation(token, TokenAppContainerSid, acs, 0, &length) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
-    {
-        acs = (TOKEN_APPCONTAINER_INFORMATION*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, length);
-        if (acs != NULL)
-        {
-          GetTokenInformation(token, TokenAppContainerSid, acs, length, &length);
-        }
-        else
-        {
-          throw std::runtime_error("Out of memory");
-        }
-    }
-
-    BOOL createProcRes = 0;
-    // Running inside AppContainer or in Windows XP
-    if ((acs != NULL && acs->TokenAppContainer != NULL) || !IsWindowsVistaOrLater())
-    {
-      // We need to break out from AppContainer. Launch with default security - registry entry will eat the user prompt
-      // See http://msdn.microsoft.com/en-us/library/bb250462(v=vs.85).aspx#wpm_elebp
-      createProcRes = CreateProcessW(engineExecutablePath.c_str(), params.GetBuffer(params.GetLength() + 1),
-                              0, 0, false, 0, 0, 0, (STARTUPINFOW*)&startupInfo, &processInformation);
-    }
-    else
-    {
-      // Launch with Low Integrity explicitly
-      HANDLE newToken;
-      DuplicateTokenEx(token, 0, 0, SecurityImpersonation, TokenPrimary, &newToken);
-
-      PSID integritySid = 0;
-      ConvertStringSidToSid(L"S-1-16-4096", &integritySid);
-      std::tr1::shared_ptr<SID> sharedIntegritySid(static_cast<SID*>(integritySid), FreeSid); // Just to simplify cleanup
-
-      TOKEN_MANDATORY_LABEL tml = {};
-      tml.Label.Attributes = SE_GROUP_INTEGRITY;
-      tml.Label.Sid = integritySid;
-
-      // Set the process integrity level
-      SetTokenInformation(newToken, TokenIntegrityLevel, &tml, sizeof(tml));
-
-      STARTUPINFO startupInfo = {};
-      PROCESS_INFORMATION processInformation = {};
-
-      createProcRes = CreateProcessAsUserW(newToken, engineExecutablePath.c_str(), params.GetBuffer(params.GetLength() + 1),
-                              0, 0, false, 0, 0, 0, (STARTUPINFOW*)&startupInfo, &processInformation);
-    }
-
+    ScopedProcessInformation processInformation;
+
+    // We need to break out from AppContainer. Launch with default security - registry entry will eat the user prompt
+    // See http://msdn.microsoft.com/en-us/library/bb250462(v=vs.85).aspx#wpm_elebp
+    BOOL createProcRes = CreateProcessW(engineExecutablePath.c_str(), &params[0],
+      0, 0, false, 0, 0, 0, &startupInfo, &processInformation);
     if (!createProcRes)
     {
       throw std::runtime_error("Failed to start Adblock Plus Engine");
     }
-
-    CloseHandle(processInformation.hProcess);
-    CloseHandle(processInformation.hThread);
   }
 
   Communication::Pipe* OpenEnginePipe()
   {
     try
     {
       return new Communication::Pipe(Communication::pipeName, Communication::Pipe::MODE_CONNECT);
     }
     catch (Communication::PipeConnectionError e)
     {
       SpawnAdblockPlusEngine();
 
       const int step = 100;
       for (int timeout = ENGINE_STARTUP_TIMEOUT; timeout > 0; timeout -= step)
       {
         Sleep(step);
         try
         {
           return new Communication::Pipe(Communication::pipeName, Communication::Pipe::MODE_CONNECT);
         }
         catch (Communication::PipeConnectionError e)
         {
         }
       }
       throw std::runtime_error("Unable to open Adblock Plus Engine pipe");
     }
   }
 
-  std::vector<std::wstring> ReadStrings(Communication::InputBuffer& message)
-  {
-    int32_t count;
-    message >> count;
-
-    std::vector<std::wstring> result;
-    for (int32_t i = 0; i < count; i++)
-    {
-      std::string str;
-      message >> str;
-      result.push_back(ToUtf16String(str));
-    }
-    return result;
-  }
-
   std::vector<SubscriptionDescription> ReadSubscriptions(Communication::InputBuffer& message)
   {
     int32_t count;
     message >> count;
 
     std::vector<SubscriptionDescription> result;
     for (int32_t i = 0; i < count; i++)
     {
       SubscriptionDescription description;
       std::string url;
       message >> url;
       description.url = ToUtf16String(url);
       std::string title;
       message >> title;
       description.title = ToUtf16String(title);
       std::string specialization;
       message >> specialization;
       description.specialization = ToUtf16String(specialization);
       message >> description.listed;
       result.push_back(description);
     }
     return result;
   }
 }
 
 CAdblockPlusClient* CAdblockPlusClient::s_instance = NULL;
-
-CAdblockPlusClient::CAdblockPlusClient() : CPluginClientBase()
+CComAutoCriticalSection CAdblockPlusClient::s_criticalSectionLocal;
+
+CAdblockPlusClient::CAdblockPlusClient()
 {
   m_filter = std::auto_ptr<CPluginFilter>(new CPluginFilter());
 }
 
 bool CAdblockPlusClient::CallEngine(Communication::OutputBuffer& message, Communication::InputBuffer& inputBuffer)
 {
   DEBUG_GENERAL("CallEngine start");
   CriticalSection::Lock lock(enginePipeLock);
   try
   {
     if (!enginePipe)
       enginePipe.reset(OpenEnginePipe());
     enginePipe->WriteMessage(message);
     inputBuffer = enginePipe->ReadMessage();
   }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
+  catch (const std::exception& ex)
+  {
+    DEBUG_EXCEPTION(ex);
     return false;
   }
   DEBUG_GENERAL("CallEngine end");
   return true;
 }
 
 bool CAdblockPlusClient::CallEngine(Communication::ProcType proc, Communication::InputBuffer& inputBuffer)
 {
   Communication::OutputBuffer message;
   message << proc;
@@ skipping 19 matching lines @@
       s_instance = client;
     }
 
     instance = s_instance;
   }
   s_criticalSectionLocal.Unlock();
 
   return instance;
 }
 
-bool CAdblockPlusClient::ShouldBlock(const std::wstring& src, int contentType, const std::wstring& domain, bool addDebug)
+bool CAdblockPlusClient::ShouldBlock(const std::wstring& src, AdblockPlus::FilterEngine::ContentType contentType, const std::wstring& domain, bool addDebug)
 {
   bool isBlocked = false;
   bool isCached = false;
   m_criticalSectionCache.Lock();
   {
     auto it = m_cacheBlockedSources.find(src);
 
     isCached = it != m_cacheBlockedSources.end();
     if (isCached)
     {
       isBlocked = it->second;
     }
   }
   m_criticalSectionCache.Unlock();
 
   if (!isCached)
   {
     m_criticalSectionFilter.Lock();
     {
       isBlocked = m_filter->ShouldBlock(src, contentType, domain, addDebug);
     }
     m_criticalSectionFilter.Unlock();
 
     // Cache result, if content type is defined
-    if (contentType != CFilter::contentTypeAny)
+    if (contentType != AdblockPlus::FilterEngine::ContentType::CONTENT_TYPE_OTHER)
     {
       m_criticalSectionCache.Lock();
       {
         m_cacheBlockedSources[src] = isBlocked;
       }
       m_criticalSectionCache.Unlock();
     }
   }
   return isBlocked;
 }
 
 bool CAdblockPlusClient::IsElementHidden(const std::wstring& tag, IHTMLElement* pEl, const std::wstring& domain, const std::wstring& indent, CPluginFilter* filter)
 {
   bool isHidden;
   m_criticalSectionFilter.Lock();
   {
     isHidden = filter && filter->IsElementHidden(tag, pEl, domain, indent);
   }
   m_criticalSectionFilter.Unlock();
   return isHidden;
 }
 
 bool CAdblockPlusClient::IsWhitelistedUrl(const std::wstring& url, const std::vector<std::string>& frameHierarchy)
 {
+  return !GetWhitelistingFilter(url, frameHierarchy).empty();
+}
+
+std::string CAdblockPlusClient::GetWhitelistingFilter(const std::wstring& url, const std::vector<std::string>& frameHierarchy)
+{
   DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" start").c_str());
   Communication::OutputBuffer request;
-  request << Communication::PROC_IS_WHITELISTED_URL << ToUtf8String(url) << frameHierarchy;
-
-  Communication::InputBuffer response;
-  if (!CallEngine(request, response)) 
-    return false;
-
-  bool isWhitelisted;
-  response >> isWhitelisted;
+  request << Communication::PROC_GET_WHITELISTING_FITER << ToUtf8String(url) << frameHierarchy;
+
+  Communication::InputBuffer response;
+  if (!CallEngine(request, response)) 
+    return "";
+
+  std::string filterText;
+  response >> filterText;
 
   DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" end").c_str());
-  return isWhitelisted;
+  return filterText;
 }
 
 bool CAdblockPlusClient::IsElemhideWhitelistedOnDomain(const std::wstring& url, const std::vector<std::string>& frameHierarchy)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_IS_ELEMHIDE_WHITELISTED_ON_URL << ToUtf8String(url) << frameHierarchy;
 
   Communication::InputBuffer response;
   if (!CallEngine(request, response)) 
     return false;
 
   bool isWhitelisted;
   response >> isWhitelisted;
   return isWhitelisted;
 }
 
-bool CAdblockPlusClient::Matches(const std::wstring& url, const std::wstring& contentType, const std::wstring& domain)
-{
-  Communication::OutputBuffer request;
-  request << Communication::PROC_MATCHES << ToUtf8String(url) << ToUtf8String(contentType) << ToUtf8String(domain);
+bool CAdblockPlusClient::Matches(const std::wstring& url, AdblockPlus::FilterEngine::ContentType contentType, const std::wstring& domain)
+{
+  Communication::OutputBuffer request;
+  request << Communication::PROC_MATCHES << ToUtf8String(url) << static_cast<int32_t>(contentType) << ToUtf8String(domain);
 
   Communication::InputBuffer response;
   if (!CallEngine(request, response)) 
     return false;
 
   bool match;
   response >> match;
   return match;
 }
 
 std::vector<std::wstring> CAdblockPlusClient::GetElementHidingSelectors(const std::wstring& domain)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_GET_ELEMHIDE_SELECTORS << ToUtf8String(domain);
 
   Communication::InputBuffer response;
   if (!CallEngine(request, response)) 
     return std::vector<std::wstring>();
-  return ReadStrings(response);
+
+  std::vector<std::string> selectors;
+  response >> selectors;
+  return ToUtf16Strings(selectors);
 }
 
 std::vector<SubscriptionDescription> CAdblockPlusClient::FetchAvailableSubscriptions()
 {
   Communication::InputBuffer response;
   if (!CallEngine(Communication::PROC_AVAILABLE_SUBSCRIPTIONS, response)) 
     return std::vector<SubscriptionDescription>();
   return ReadSubscriptions(response);
 }
 
@@ skipping 45 matching lines @@
 void CAdblockPlusClient::UpdateAllSubscriptions()
 {
   CallEngine(Communication::PROC_UPDATE_ALL_SUBSCRIPTIONS);
 }
 
 std::vector<std::wstring> CAdblockPlusClient::GetExceptionDomains()
 {
   Communication::InputBuffer response;
   if (!CallEngine(Communication::PROC_GET_EXCEPTION_DOMAINS, response)) 
     return std::vector<std::wstring>();
-  return ReadStrings(response);
+
+  std::vector<std::string> domains;
+  response >> domains;
+  return ToUtf16Strings(domains);
 }
 
 bool CAdblockPlusClient::IsFirstRun()
 {
   DEBUG_GENERAL("IsFirstRun");
   Communication::InputBuffer response;
   if (!CallEngine(Communication::PROC_IS_FIRST_RUN_ACTION_NEEDED, response)) return false;
   bool res;
   response >> res;
   return res;
 }
 
 void CAdblockPlusClient::AddFilter(const std::wstring& text)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_ADD_FILTER << ToUtf8String(text);
   CallEngine(request);
 }
 
 void CAdblockPlusClient::RemoveFilter(const std::wstring& text)
 {
-  Communication::OutputBuffer request;
-  request << Communication::PROC_REMOVE_FILTER << ToUtf8String(text);
+  RemoveFilter(ToUtf8String(text));
+}
+
+void CAdblockPlusClient::RemoveFilter(const std::string& text)
+{
+  Communication::OutputBuffer request;
+  request << Communication::PROC_REMOVE_FILTER << text;
   CallEngine(request);
 }
 
 void CAdblockPlusClient::SetPref(const std::wstring& name, const std::wstring& value)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_SET_PREF << ToUtf8String(name) << ToUtf8String(value);
   CallEngine(request);
 }
 
@@ skipping 137 matching lines @@
   DEBUG_GENERAL("CompareVersions");
   Communication::OutputBuffer request;
   request << Communication::PROC_COMPARE_VERSIONS << ToUtf8String(v1) << ToUtf8String(v2);
   Communication::InputBuffer response;
   if (!CallEngine(request, response))
     return 0;
   int result;
   response >> result;
   return result;
 }