| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "CookieManager.h" | |
| #include <UrlMon.h> | |
| #include <wininet.h> | |
| #include "errorcodes.h" | |
| #include "logging.h" | |
| #include "BrowserCookie.h" | |
| #include "HookProcessor.h" | |
| #include "messages.h" | |
| #include "StringUtilities.h" | |
| #define TICKS_PER_SECOND 10000000 | |
| #define UNIX_TIME_OFFSET_SECONDS 11644473600L | |
| namespace webdriver { | |
| struct CookieSendMessageInfo { | |
| HWND window_handle; | |
| unsigned int message; | |
| }; | |
| CookieManager::CookieManager(void) { | |
| this->window_handle_ = NULL; | |
| } | |
| CookieManager::~CookieManager(void) { | |
| } | |
| void CookieManager::Initialize(HWND window_handle) { | |
| LOG(TRACE) << "Entering CookieManager::Initialize"; | |
| this->window_handle_ = window_handle; | |
| } | |
| bool CookieManager::IsAdvancedCookiesApi() { | |
| FARPROC address = NULL; | |
| HMODULE wininet_handle = ::GetModuleHandle(L"wininet"); | |
| if (wininet_handle) { | |
| address = ::GetProcAddress(wininet_handle, "InternetGetCookieEx2"); | |
| } | |
| return address != NULL; | |
| } | |
| int CookieManager::SetCookie(const std::string& url, | |
| const BrowserCookie& cookie) { | |
| std::string full_data = url + "|" + cookie.ToString(); | |
| WPARAM set_flags = 0; | |
| if (cookie.is_httponly()) { | |
| set_flags = INTERNET_COOKIE_HTTPONLY; | |
| } | |
| HookSettings hook_settings; | |
| hook_settings.hook_procedure_name = "CookieWndProc"; | |
| hook_settings.hook_procedure_type = WH_CALLWNDPROC; | |
| hook_settings.window_handle = this->window_handle_; | |
| hook_settings.communication_type = OneWay; | |
| HookProcessor hook; | |
| if (!hook.CanSetWindowsHook(this->window_handle_)) { | |
| LOG(WARN) << "Cannot set cookie because driver and browser are not the " | |
| << "same bit-ness."; | |
| return EUNHANDLEDERROR; | |
| } | |
| hook.Initialize(hook_settings); | |
| hook.PushData(StringUtilities::ToWString(full_data)); | |
| ::SendMessage(this->window_handle_, WD_SET_COOKIE, set_flags, NULL); | |
| int status = HookProcessor::GetDataBufferSize(); | |
| if (status != 0) { | |
| LOG(WARN) << "Setting cookie encountered error " << status; | |
| return EINVALIDCOOKIEDOMAIN; | |
| } | |
| return WD_SUCCESS; | |
| } | |
| int CookieManager::GetCookies(const std::string& url, | |
| std::vector<BrowserCookie>* all_cookies) { | |
| LOG(TRACE) << "Entering CookieManager::GetCookies"; | |
| std::wstring wide_url = StringUtilities::ToWString(url); | |
| CComPtr<IUri> parsed_url; | |
| ::CreateUri(wide_url.c_str(), Uri_CREATE_ALLOW_RELATIVE, 0, &parsed_url); | |
| DWORD url_scheme = 0; | |
| parsed_url->GetScheme(&url_scheme); | |
| bool is_secure_url = URL_SCHEME_HTTPS == url_scheme; | |
| HookSettings hook_settings; | |
| hook_settings.hook_procedure_name = "CookieWndProc"; | |
| hook_settings.hook_procedure_type = WH_CALLWNDPROC; | |
| hook_settings.window_handle = this->window_handle_; | |
| hook_settings.communication_type = TwoWay; | |
| HookProcessor hook; | |
| if (!hook.CanSetWindowsHook(this->window_handle_)) { | |
| LOG(WARN) << "Cannot get cookies because driver and browser are not the " | |
| << "same bit-ness."; | |
| return EUNHANDLEDERROR; | |
| } | |
| hook.Initialize(hook_settings); | |
| bool supports_advanced_api = this->IsAdvancedCookiesApi(); | |
| if (supports_advanced_api) { | |
| // The version of WinINet installed supports the InternetGetCookieEx2 | |
| // API, which gets all cookies (session and persistent) at once. | |
| std::wstring raw_cookie_data = | |
| this->SendGetCookieMessage(wide_url, | |
| WD_GET_ALL_COOKIES, | |
| &hook); | |
| std::string all_cookies_list = StringUtilities::ToString(raw_cookie_data); | |
| std::map<std::string, BrowserCookie> cookies; | |
| this->ParseCookieList(all_cookies_list, | |
| is_secure_url, | |
| &cookies); | |
| std::map<std::string, BrowserCookie>::const_iterator cookie_iterator; | |
| for (cookie_iterator = cookies.begin(); | |
| cookie_iterator != cookies.end(); | |
| ++cookie_iterator) { | |
| all_cookies->push_back(cookie_iterator->second); | |
| } | |
| } else { | |
| // Get all cookies for the current URL visible to JavaScript. | |
| std::wstring scriptable_cookie_string = | |
| this->SendGetCookieMessage(wide_url, | |
| WD_GET_SCRIPTABLE_COOKIES, | |
| &hook); | |
| std::map<std::string, std::string> scriptable_cookies; | |
| this->ParseCookieString(scriptable_cookie_string, &scriptable_cookies); | |
| // Get all cookies for the insecure version of the current URL, | |
| // which will include HttpOnly cookies. | |
| std::wstring insecure_cookie_string = | |
| this->SendGetCookieMessage(wide_url, | |
| WD_GET_HTTPONLY_COOKIES, | |
| &hook); | |
| std::map<std::string, std::string> insecure_cookies; | |
| this->ParseCookieString(insecure_cookie_string, &insecure_cookies); | |
| // Get all cookies for the current secure URL. This will include | |
| // HttpOnly cookies. | |
| std::wstring secure_cookie_string = | |
| this->SendGetCookieMessage(wide_url, | |
| WD_GET_SECURE_COOKIES, | |
| &hook); | |
| std::map<std::string, std::string> secure_cookies; | |
| this->ParseCookieString(secure_cookie_string, &secure_cookies); | |
| // Get all of the persistent cookie files in the cache for the | |
| // URL currently being browsed. | |
| std::wstring file_list = | |
| this->SendGetCookieMessage(wide_url, | |
| WD_GET_COOKIE_CACHE_FILES, | |
| &hook); | |
| std::vector<std::wstring> files; | |
| StringUtilities::Split(file_list, L"|", &files); | |
| // Parse the persistent cookie files to produce a list of | |
| // cookies. | |
| std::map<std::string, BrowserCookie> persistent_cookies; | |
| std::vector<std::wstring>::const_iterator file_iterator; | |
| for (file_iterator = files.begin(); | |
| file_iterator != files.end(); | |
| ++file_iterator) { | |
| std::string cookie_file_contents = this->ReadCookieFile(*file_iterator); | |
| this->ParseCookieList(cookie_file_contents, | |
| is_secure_url, | |
| &persistent_cookies); | |
| } | |
| // Loop through the entire list of cookies, including HttpOnly and secure | |
| // cookies. If the cookie exists as a persistent cookie, use its data from | |
| // the cache. If the cookie is found in the list of cookies visible to | |
| // JavaScript, set the HttpOnly property of the cookie to false. If the | |
| // cookie is found in the list of cookies set on the insecure version of | |
| // the URL, set the Secure property of the cookie to false. | |
| std::map<std::string, std::string>::const_iterator it = secure_cookies.begin(); | |
| for (; it != secure_cookies.end(); ++it) { | |
| BrowserCookie browser_cookie; | |
| if (persistent_cookies.find(it->first) != persistent_cookies.end()) { | |
| browser_cookie = persistent_cookies[it->first]; | |
| } else { | |
| browser_cookie.set_name(it->first); | |
| browser_cookie.set_value(it->second); | |
| browser_cookie.set_is_httponly(scriptable_cookies.find(it->first) == scriptable_cookies.end()); | |
| browser_cookie.set_is_secure(insecure_cookies.find(it->first) == insecure_cookies.end()); | |
| } | |
| all_cookies->push_back(browser_cookie); | |
| } | |
| } | |
| return WD_SUCCESS; | |
| } | |
| bool CookieManager::DeleteCookie(const std::string& url, | |
| const BrowserCookie& cookie) { | |
| std::wstring wide_url = StringUtilities::ToWString(url); | |
| CComPtr<IUri> uri_pointer; | |
| ::CreateUri(wide_url.c_str(), Uri_CREATE_ALLOW_RELATIVE, 0, &uri_pointer); | |
| CComBSTR host_bstr; | |
| uri_pointer->GetHost(&host_bstr); | |
| std::wstring wide_domain = host_bstr; | |
| CComBSTR path_bstr; | |
| uri_pointer->GetPath(&path_bstr); | |
| std::wstring wide_path = path_bstr; | |
| std::string domain = StringUtilities::ToString(wide_domain); | |
| std::string path = StringUtilities::ToString(wide_path); | |
| // N.B., We can hard-code the value and expiration time, since | |
| // we are deleting the cookie. So the value will be "deleted", | |
| // and the expiration time will be 1000 milliseconds after the | |
| // zero date (or Thu 1 Jan 1970 00:00:01 GMT). | |
| BrowserCookie recursive_cookie = cookie.Copy(); | |
| recursive_cookie.set_domain(domain); | |
| recursive_cookie.set_path(path); | |
| recursive_cookie.set_value("deleted"); | |
| recursive_cookie.set_expiration_time(1000); | |
| return this->RecursivelyDeleteCookie(url, recursive_cookie); | |
| } | |
| bool CookieManager::RecursivelyDeleteCookie(const std::string& url, | |
| const BrowserCookie& cookie) { | |
| // TODO: Optimize this path from the recursive to only | |
| // call setting the cookie as often as needed. | |
| BrowserCookie recursive_cookie = cookie.Copy(); | |
| recursive_cookie.set_domain("." + cookie.domain()); | |
| return this->RecurseCookiePath(url, recursive_cookie); | |
| } | |
| bool CookieManager::RecurseCookiePath(const std::string& url, | |
| const BrowserCookie& cookie) { | |
| size_t number_of_characters = 0; | |
| size_t slash_index = cookie.path().find_last_of('/'); | |
| size_t final_index = cookie.path().size() - 1; | |
| if (slash_index == final_index) { | |
| number_of_characters = slash_index; | |
| } | |
| else { | |
| number_of_characters = slash_index + 1; | |
| } | |
| if (slash_index != std::string::npos) { | |
| BrowserCookie path_cookie = cookie.Copy(); | |
| path_cookie.set_path(cookie.path().substr(0, number_of_characters)); | |
| bool deleted = this->RecurseCookiePath(url, path_cookie); | |
| } | |
| return this->RecurseCookieDomain(url, cookie); | |
| } | |
| bool CookieManager::RecurseCookieDomain(const std::string& url, | |
| const BrowserCookie& cookie) { | |
| int status = this->SetCookie(url, cookie); | |
| size_t dot_index = cookie.domain().find_first_of('.'); | |
| if (dot_index == 0) { | |
| BrowserCookie first_dot_cookie = cookie.Copy(); | |
| first_dot_cookie.set_domain(cookie.domain().substr(1)); | |
| return this->RecurseCookieDomain(url, first_dot_cookie); | |
| } else if (dot_index != std::string::npos) { | |
| BrowserCookie no_dot_cookie = cookie.Copy(); | |
| no_dot_cookie.set_domain(cookie.domain().substr(dot_index)); | |
| return this->RecurseCookieDomain(url, no_dot_cookie); | |
| } | |
| BrowserCookie no_domain_cookie = cookie.Copy(); | |
| no_domain_cookie.set_domain(""); | |
| status = this->SetCookie(url, no_domain_cookie); | |
| return status == WD_SUCCESS; | |
| } | |
| std::string CookieManager::ReadCookieFile(const std::wstring& file_name) { | |
| LOG(TRACE) << "Entering CookieManager::ReadCookieFile"; | |
| HANDLE file_handle = ::CreateFile(file_name.c_str(), | |
| GENERIC_READ, | |
| FILE_SHARE_READ | FILE_SHARE_WRITE, | |
| NULL, | |
| OPEN_EXISTING, | |
| 0, | |
| NULL); | |
| // Read the cookie file. Hopefully, we will never have a 2GB cookie file. | |
| DWORD file_size_high = 0; | |
| DWORD file_size_low = ::GetFileSize(file_handle, &file_size_high); | |
| std::vector<char> file_content(file_size_low + 1); | |
| DWORD bytes_read = 0; | |
| ::ReadFile(file_handle, &file_content[0], file_size_low, &bytes_read, NULL); | |
| ::CloseHandle(file_handle); | |
| // Null-terminate and convert to a string for easier manipulation. | |
| file_content[bytes_read - 1] = '\0'; | |
| std::string cookie_file_contents = &file_content[0]; | |
| return cookie_file_contents; | |
| } | |
| void CookieManager::ParseCookieList(const std::string& cookie_file_contents, | |
| const bool include_secure_cookies, | |
| std::map<std::string, BrowserCookie>* cookies) { | |
| LOG(TRACE) << "Entering CookieManager::ParseCookieList"; | |
| // Each cookie in the file is a record structure separated by | |
| // a line containing a single asterisk ('*'). Split the file | |
| // content on this delimiter, and parse each record. | |
| std::vector<std::string> persistent_cookie_strings; | |
| StringUtilities::Split(cookie_file_contents, | |
| "\n*\n", | |
| &persistent_cookie_strings); | |
| std::vector<std::string>::const_iterator cookie_string_iterator; | |
| for (cookie_string_iterator = persistent_cookie_strings.begin(); | |
| cookie_string_iterator != persistent_cookie_strings.end(); | |
| ++cookie_string_iterator) { | |
| BrowserCookie persistent_cookie = | |
| this->ParseSingleCookie(*cookie_string_iterator); | |
| if (include_secure_cookies || !persistent_cookie.is_secure()) { | |
| // Omit the cookie if it's 'secure' flag is set and we are *not* | |
| // browsing using SSL. | |
| cookies->insert( | |
| std::pair<std::string, BrowserCookie>(persistent_cookie.name(), | |
| persistent_cookie)); | |
| } | |
| } | |
| } | |
| BrowserCookie CookieManager::ParseSingleCookie(const std::string& cookie) { | |
| LOG(TRACE) << "Entering CookieManager::ParsePersistentCookieInfo"; | |
| // Cookies represented by a structured string record type. | |
| // This structure is modeled after how some versions of IE | |
| // stored perisitent cookeis as files on disk. Each cookie | |
| // is represented by 8 lines in the file separated by line | |
| // feed (0xA) characters, with the following format: | |
| // | |
| // cookie_name | |
| // cookie_value | |
| // cookie.domain.value/cookie/path/value/ | |
| // <integer representing cookie flags> | |
| // <unsigned long representing the low 32 bits of expiration time> | |
| // <unsigned long representing the high 32 bits of expiration time> | |
| // <unsigned long representing the low 32 bits of last-modified time> | |
| // <unsigned long representing the high 32 bits of last-modified time> | |
| // | |
| // Read each of these lines and set the appropriate values | |
| // in the resulting cookie object. | |
| std::vector<std::string> cookie_parts; | |
| StringUtilities::Split(cookie, "\n", &cookie_parts); | |
| BrowserCookie cookie_to_return; | |
| cookie_to_return.set_name(cookie_parts[0]); | |
| cookie_to_return.set_value(cookie_parts[1]); | |
| size_t position = cookie_parts[2].find_first_of("/"); | |
| cookie_to_return.set_domain(cookie_parts[2].substr(0, position)); | |
| cookie_to_return.set_path(cookie_parts[2].substr(position)); | |
| int flags = atoi(cookie_parts[3].c_str()); | |
| cookie_to_return.set_is_secure(INTERNET_COOKIE_IS_SECURE == (INTERNET_COOKIE_IS_SECURE & flags)); | |
| cookie_to_return.set_is_httponly(INTERNET_COOKIE_HTTPONLY == (INTERNET_COOKIE_HTTPONLY & flags)); | |
| if (cookie_parts[4].size() > 0 && cookie_parts[5].size() > 0) { | |
| unsigned long expiry_time_low = strtoul(cookie_parts[4].c_str(), NULL, 10); | |
| unsigned long expiry_time_high = strtoul(cookie_parts[5].c_str(), NULL, 10); | |
| unsigned long long expiration_time = (expiry_time_high * static_cast<long long>(pow(2.0, 32))) + expiry_time_low; | |
| // Cookie expiration time is stored in the file as the number | |
| // of 100-nanosecond ticks since 1 January 1601 12:00:00 AM GMT. | |
| // We need the number of seconds since 1 January 1970 12:00:00 AM GMT. | |
| // This is the conversion. | |
| unsigned long cookie_expiration_time = static_cast<unsigned long>((expiration_time / TICKS_PER_SECOND) - UNIX_TIME_OFFSET_SECONDS); | |
| cookie_to_return.set_expiration_time(cookie_expiration_time); | |
| } | |
| return cookie_to_return; | |
| } | |
| void CookieManager::ParseCookieString(const std::wstring& cookie_string, | |
| std::map<std::string, std::string>* cookies) { | |
| LOG(TRACE) << "Entering CookieManager::ParseCookieString"; | |
| std::wstring cookie_string_copy = cookie_string; | |
| while (cookie_string_copy.size() > 0) { | |
| size_t cookie_delimiter_pos = cookie_string_copy.find(L"; "); | |
| std::wstring cookie = cookie_string_copy.substr(0, cookie_delimiter_pos); | |
| if (cookie_delimiter_pos == std::wstring::npos) { | |
| cookie_string_copy = L""; | |
| } else { | |
| cookie_string_copy = cookie_string_copy.substr(cookie_delimiter_pos + 2); | |
| } | |
| size_t cookie_separator_pos(cookie.find_first_of(L"=")); | |
| std::string cookie_name(StringUtilities::ToString(cookie.substr(0, cookie_separator_pos))); | |
| std::string cookie_value(StringUtilities::ToString(cookie.substr(cookie_separator_pos + 1))); | |
| cookies->insert(std::pair<std::string, std::string>(cookie_name, cookie_value)); | |
| } | |
| } | |
| std::wstring CookieManager::SendGetCookieMessage(const std::wstring& url, | |
| const unsigned int message, | |
| HookProcessor* hook) { | |
| LOG(TRACE) << "Entering CookieManager::SendGetCookieMessage"; | |
| hook->PushData(url); | |
| // Since the named pipe server has to wait for the named pipe client | |
| // injected into the browser to connect to it before reading the data, | |
| // and since SendMessage is synchronous, we need to send the message | |
| // from a different thread to avoid a deadlock. | |
| CookieSendMessageInfo info; | |
| info.window_handle = this->window_handle_; | |
| info.message = message; | |
| unsigned int thread_id = 0; | |
| HANDLE thread_handle = reinterpret_cast<HANDLE>(_beginthreadex(NULL, | |
| 0, | |
| &CookieManager::ThreadProc, | |
| reinterpret_cast<void*>(&info), | |
| 0, | |
| &thread_id)); | |
| if (thread_handle != NULL) { | |
| ::CloseHandle(thread_handle); | |
| } else { | |
| LOGERR(DEBUG) << "Unable to create thread"; | |
| } | |
| std::vector<char> buffer(0); | |
| int bytes = hook->PullData(&buffer); | |
| std::wstring cookies = reinterpret_cast<const wchar_t*>(&buffer[0]); | |
| return cookies; | |
| } | |
| unsigned int WINAPI CookieManager::ThreadProc(LPVOID lpParameter) { | |
| LOG(TRACE) << "Entering CookieManager::ThreadProc"; | |
| CookieSendMessageInfo* info = reinterpret_cast<CookieSendMessageInfo*>(lpParameter); | |
| DWORD process_id = ::GetCurrentProcessId(); | |
| LRESULT result = ::SendMessage(info->window_handle, | |
| info->message, | |
| process_id, | |
| NULL); | |
| return 0; | |
| } | |
| } // namespace webdriver | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // In order to run the IE driver against versions of IE that do not include | |
| // a version of WinINet.dll that supports the InternetGetCookiesEx2 API, | |
| // we must access the API in a way that does not import it into our DLL. | |
| // To that end, we duplicate the INTERNET_COOKIE2 structure here, and will | |
| // call the API (if it exists) via GetModuleHandle and GetProcAddress. | |
| typedef struct { | |
| PWSTR pwszName; | |
| PWSTR pwszValue; | |
| PWSTR pwszDomain; | |
| PWSTR pwszPath; | |
| DWORD dwFlags; | |
| FILETIME ftExpires; | |
| BOOL fExpiresSet; | |
| } INTERNETCOOKIE2; | |
| typedef void* (__stdcall *InternetFreeCookiesProc)(INTERNETCOOKIE2*, DWORD); | |
| typedef DWORD(__stdcall *InternetGetCookieEx2Proc)(PCWSTR, PCWSTR, DWORD, INTERNETCOOKIE2**, PDWORD); | |
| LRESULT CALLBACK CookieWndProc(int nCode, WPARAM wParam, LPARAM lParam) { | |
| CWPSTRUCT* call_window_proc_struct = reinterpret_cast<CWPSTRUCT*>(lParam); | |
| if (WM_COPYDATA == call_window_proc_struct->message) { | |
| COPYDATASTRUCT* data = reinterpret_cast<COPYDATASTRUCT*>(call_window_proc_struct->lParam); | |
| webdriver::HookProcessor::CopyDataToBuffer(data->cbData, data->lpData); | |
| } else if (WD_GET_ALL_COOKIES == call_window_proc_struct->message) { | |
| std::wstring url = webdriver::HookProcessor::CopyWStringFromBuffer(); | |
| int driver_process_id = static_cast<int>(call_window_proc_struct->wParam); | |
| CComPtr<IUri> uri_pointer; | |
| HRESULT hr = ::CreateUri(url.c_str(), Uri_CREATE_ALLOW_RELATIVE, 0, &uri_pointer); | |
| DWORD scheme = 0; | |
| uri_pointer->GetScheme(&scheme); | |
| CComBSTR scheme_bstr; | |
| uri_pointer->GetSchemeName(&scheme_bstr); | |
| CComBSTR host_bstr; | |
| uri_pointer->GetHost(&host_bstr); | |
| CComBSTR path_bstr; | |
| uri_pointer->GetPath(&path_bstr); | |
| std::wstring parsed_uri = scheme_bstr; | |
| parsed_uri.append(L"://"); | |
| parsed_uri.append(host_bstr); | |
| parsed_uri.append(path_bstr); | |
| InternetGetCookieEx2Proc get_cookie_proc = NULL; | |
| InternetFreeCookiesProc free_cookies_proc = NULL; | |
| HMODULE wininet_handle = ::GetModuleHandle(L"wininet"); | |
| if (wininet_handle) { | |
| get_cookie_proc = reinterpret_cast<InternetGetCookieEx2Proc>(::GetProcAddress(wininet_handle, "InternetGetCookieEx2")); | |
| free_cookies_proc = reinterpret_cast<InternetFreeCookiesProc>(::GetProcAddress(wininet_handle, "InternetFreeCookies")); | |
| } | |
| DWORD cookie_count = 0; | |
| INTERNETCOOKIE2* cookie_pointer = NULL; | |
| DWORD success = 1; | |
| if (get_cookie_proc) { | |
| success = get_cookie_proc(parsed_uri.c_str(), | |
| NULL, | |
| INTERNET_COOKIE_NON_SCRIPT, | |
| &cookie_pointer, | |
| &cookie_count); | |
| } | |
| if (success == 0) { | |
| // Mimic the format of the old persistent cookie files for ease of | |
| // transmission back to the driver and parsing. | |
| std::wstring all_cookies = L""; | |
| for (DWORD cookie_index = 0; cookie_index < cookie_count; ++cookie_index) { | |
| if (all_cookies.size() > 0) { | |
| all_cookies.append(L"\n*\n"); | |
| } | |
| INTERNETCOOKIE2* current_cookie = cookie_pointer + cookie_index; | |
| std::wstring cookie_name = L""; | |
| if (current_cookie->pwszName) { | |
| // Note that the spec appears to allow "nameless" cookies, | |
| // which clients like Selenium may not support. | |
| cookie_name = current_cookie->pwszName; | |
| } | |
| std::wstring cookie_value = L""; | |
| if (current_cookie->pwszValue) { | |
| cookie_value = current_cookie->pwszValue; | |
| } | |
| // TODO: The spec does not allow a cookie with an empty name | |
| // and value. It's unclear what the driver could do in this | |
| // case, but we should probably handle it somehow in the off | |
| // chance it ever comes up. | |
| std::wstring cookie_domain = L""; | |
| if (current_cookie->pwszDomain) { | |
| cookie_domain = current_cookie->pwszDomain; | |
| } | |
| std::wstring cookie_path = L""; | |
| if (current_cookie->pwszPath) { | |
| cookie_path = current_cookie->pwszPath; | |
| } | |
| DWORD flags = current_cookie->dwFlags; | |
| FILETIME expires = current_cookie->ftExpires; | |
| all_cookies.append(cookie_name).append(L"\n"); | |
| all_cookies.append(cookie_value).append(L"\n"); | |
| all_cookies.append(cookie_domain).append(L"/").append(cookie_path).append(L"\n"); | |
| all_cookies.append(std::to_wstring(flags)).append(L"\n"); | |
| // If the expiration time is set, add it to the string for the cookie. | |
| // If not, append empty fields to the record so subsequent parsing | |
| // of the string will still work. | |
| if (current_cookie->fExpiresSet) { | |
| all_cookies.append(std::to_wstring(expires.dwLowDateTime)).append(L"\n"); | |
| all_cookies.append(std::to_wstring(expires.dwHighDateTime)).append(L"\n"); | |
| } else { | |
| all_cookies.append(L"\n\n"); | |
| } | |
| } | |
| free_cookies_proc(cookie_pointer, cookie_count); | |
| webdriver::HookProcessor::CopyWStringToBuffer(all_cookies); | |
| } else { | |
| webdriver::HookProcessor::SetDataBufferSize(sizeof(wchar_t)); | |
| } | |
| webdriver::HookProcessor::WriteBufferToPipe(driver_process_id); | |
| } else if (WD_GET_HTTPONLY_COOKIES == call_window_proc_struct->message || | |
| WD_GET_SCRIPTABLE_COOKIES == call_window_proc_struct->message || | |
| WD_GET_SECURE_COOKIES == call_window_proc_struct->message) { | |
| std::wstring url = webdriver::HookProcessor::CopyWStringFromBuffer(); | |
| int driver_process_id = static_cast<int>(call_window_proc_struct->wParam); | |
| DWORD get_cookie_flags = 0; | |
| if (WD_GET_HTTPONLY_COOKIES == call_window_proc_struct->message || | |
| WD_GET_SECURE_COOKIES == call_window_proc_struct->message) { | |
| get_cookie_flags = INTERNET_COOKIE_HTTPONLY; | |
| } | |
| CComPtr<IUri> uri_pointer; | |
| HRESULT hr = ::CreateUri(url.c_str(), Uri_CREATE_ALLOW_RELATIVE, 0, &uri_pointer); | |
| DWORD scheme = 0; | |
| uri_pointer->GetScheme(&scheme); | |
| CComBSTR scheme_bstr; | |
| uri_pointer->GetSchemeName(&scheme_bstr); | |
| CComBSTR host_bstr; | |
| uri_pointer->GetHost(&host_bstr); | |
| CComBSTR path_bstr; | |
| uri_pointer->GetPath(&path_bstr); | |
| // Get only the cookies for the base URL, omitting port, if there is one. | |
| // N.B., we only return cookies secure cookies when browsing a site using | |
| // SSL. The browser won't see cookies with the 'secure' flag for sites | |
| // visited using plain http. | |
| std::wstring parsed_uri = L"http"; | |
| if ((WD_GET_SECURE_COOKIES == call_window_proc_struct->message || | |
| WD_GET_SCRIPTABLE_COOKIES == call_window_proc_struct->message) && | |
| URL_SCHEME_HTTPS == scheme) { | |
| parsed_uri.append(L"s"); | |
| } | |
| parsed_uri.append(L"://"); | |
| parsed_uri.append(host_bstr); | |
| parsed_uri.append(path_bstr); | |
| // Call InternetGetCookieEx once to get the size of the buffer needed, | |
| // then call again with the appropriately sized buffer allocated. | |
| DWORD buffer_size = 0; | |
| BOOL success = ::InternetGetCookieEx(parsed_uri.c_str(), | |
| NULL, | |
| NULL, | |
| &buffer_size, | |
| get_cookie_flags, | |
| NULL); | |
| if (success) { | |
| webdriver::HookProcessor::SetDataBufferSize(buffer_size); | |
| ::InternetGetCookieEx(parsed_uri.c_str(), | |
| NULL, | |
| reinterpret_cast<LPTSTR>(webdriver::HookProcessor::GetDataBufferAddress()), | |
| &buffer_size, | |
| get_cookie_flags, | |
| NULL); | |
| webdriver::HookProcessor::WriteBufferToPipe(driver_process_id); | |
| } else { | |
| if (ERROR_NO_MORE_ITEMS == ::GetLastError()) { | |
| webdriver::HookProcessor::SetDataBufferSize(sizeof(wchar_t)); | |
| webdriver::HookProcessor::WriteBufferToPipe(driver_process_id); | |
| } | |
| } | |
| } else if (WD_GET_COOKIE_CACHE_FILES == call_window_proc_struct->message) { | |
| int driver_process_id = static_cast<int>(call_window_proc_struct->wParam); | |
| std::wstring file_list = L""; | |
| std::wstring url = webdriver::HookProcessor::CopyWStringFromBuffer(); | |
| // We need to remove the port to find the entry in the cache. | |
| CComPtr<IUri> uri_pointer; | |
| HRESULT hr = ::CreateUri(url.c_str(), Uri_CREATE_ALLOW_RELATIVE, 0, &uri_pointer); | |
| CComBSTR host_bstr; | |
| uri_pointer->GetHost(&host_bstr); | |
| CComBSTR path_bstr; | |
| uri_pointer->GetPath(&path_bstr); | |
| std::wstring parsed_uri = host_bstr; | |
| parsed_uri.append(path_bstr); | |
| // A 2048-byte buffer should be large enough to handle cookie | |
| // cache entries in all but the most extreme cases. | |
| HANDLE cache_enum_handle = NULL; | |
| DWORD entry_size = 2048; | |
| LPINTERNET_CACHE_ENTRY_INFO entry = NULL; | |
| std::vector<char> entry_buffer(entry_size); | |
| entry = reinterpret_cast<INTERNET_CACHE_ENTRY_INFO*>(&entry_buffer[0]); | |
| cache_enum_handle = ::FindFirstUrlCacheEntry(L"cookie:", | |
| entry, | |
| &entry_size); | |
| if (cache_enum_handle == NULL && | |
| ERROR_INSUFFICIENT_BUFFER == ::GetLastError()) { | |
| entry_buffer.resize(entry_size); | |
| entry = reinterpret_cast<INTERNET_CACHE_ENTRY_INFO*>(&entry_buffer[0]); | |
| cache_enum_handle = ::FindFirstUrlCacheEntry(L"cookie:", | |
| entry, | |
| &entry_size); | |
| } | |
| while (cache_enum_handle != NULL) { | |
| if (COOKIE_CACHE_ENTRY == (entry->CacheEntryType & COOKIE_CACHE_ENTRY)) { | |
| std::wstring name = entry->lpszSourceUrlName; | |
| size_t name_separator_pos(name.find_first_of(L"@")); | |
| std::wstring domain = name.substr(name_separator_pos + 1); | |
| if (parsed_uri.find(domain) != std::wstring::npos) { | |
| if (file_list.size() > 0) { | |
| file_list.append(L"|"); | |
| } | |
| file_list.append(entry->lpszLocalFileName); | |
| } | |
| } | |
| BOOL success = ::FindNextUrlCacheEntry(cache_enum_handle, | |
| entry, | |
| &entry_size); | |
| if (!success) { | |
| DWORD error = ::GetLastError(); | |
| if (ERROR_INSUFFICIENT_BUFFER == error) { | |
| entry_buffer.resize(entry_size); | |
| BOOL other_success = ::FindNextUrlCacheEntry(cache_enum_handle, | |
| entry, | |
| &entry_size); | |
| } else if (ERROR_NO_MORE_ITEMS == error) { | |
| ::FindCloseUrlCache(cache_enum_handle); | |
| cache_enum_handle = NULL; | |
| } | |
| } | |
| } | |
| webdriver::HookProcessor::CopyWStringToBuffer(file_list); | |
| webdriver::HookProcessor::WriteBufferToPipe(driver_process_id); | |
| } else if (WD_SET_COOKIE == call_window_proc_struct->message) { | |
| DWORD set_cookie_flags = static_cast<DWORD>(call_window_proc_struct->wParam); | |
| std::wstring cookie_data = webdriver::HookProcessor::CopyWStringFromBuffer(); | |
| size_t url_separator_pos = cookie_data.find_first_of(L"|"); | |
| std::wstring url = cookie_data.substr(0, url_separator_pos); | |
| std::wstring cookie = cookie_data.substr(url_separator_pos + 1); | |
| CComPtr<IUri> uri_pointer; | |
| HRESULT hr = ::CreateUri(url.c_str(), Uri_CREATE_ALLOW_RELATIVE, 0, &uri_pointer); | |
| CComBSTR scheme_bstr; | |
| uri_pointer->GetSchemeName(&scheme_bstr); | |
| CComBSTR host_bstr; | |
| uri_pointer->GetHost(&host_bstr); | |
| std::wstring parsed_uri = scheme_bstr; | |
| parsed_uri.append(L"://"); | |
| parsed_uri.append(host_bstr); | |
| // Leverage the shared data buffer size to return the error code | |
| // back to the driver, if necessary. | |
| DWORD cookie_set = ::InternetSetCookieEx(parsed_uri.c_str(), | |
| NULL, | |
| cookie.c_str(), | |
| set_cookie_flags, | |
| NULL); | |
| if (cookie_set) { | |
| webdriver::HookProcessor::SetDataBufferSize(0); | |
| } else { | |
| DWORD error = ::GetLastError(); | |
| webdriver::HookProcessor::SetDataBufferSize(error); | |
| } | |
| } | |
| return ::CallNextHookEx(NULL, nCode, wParam, lParam); | |
| } | |
| #ifdef __cplusplus | |
| } | |
| #endif |