1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/http/url_security_manager.h"
#include <urlmon.h>
#include <wrl/client.h>
#include "base/logging.h"
#include "base/notreached.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "net/http/http_auth_filter.h"
#include "url/scheme_host_port.h"
// The Windows implementation of URLSecurityManager uses WinINet/IE's
// URL security zone manager. See the MSDN page "URL Security Zones" at
// http://msdn.microsoft.com/en-us/library/ms537021(VS.85).aspx for more
// info on the Internet Security Manager and Internet Zone Manager objects.
//
// On Windows, we honor the WinINet/IE settings and group policy related to
// URL Security Zones. See the Microsoft Knowledge Base article 182569
// "Internet Explorer security zones registry entries for advanced users"
// (http://support.microsoft.com/kb/182569) for more info on these registry
// keys.
namespace net {
class URLSecurityManagerWin : public URLSecurityManagerAllowlist {
public:
URLSecurityManagerWin();
URLSecurityManagerWin(const URLSecurityManagerWin&) = delete;
URLSecurityManagerWin& operator=(const URLSecurityManagerWin&) = delete;
~URLSecurityManagerWin() override;
// URLSecurityManager methods:
bool CanUseDefaultCredentials(
const url::SchemeHostPort& auth_scheme_host_port) const override;
private:
bool EnsureSystemSecurityManager();
Microsoft::WRL::ComPtr<IInternetSecurityManager> security_manager_;
};
URLSecurityManagerWin::URLSecurityManagerWin() = default;
URLSecurityManagerWin::~URLSecurityManagerWin() = default;
bool URLSecurityManagerWin::CanUseDefaultCredentials(
const url::SchemeHostPort& auth_scheme_host_port) const {
if (HasDefaultAllowlist())
return URLSecurityManagerAllowlist::CanUseDefaultCredentials(
auth_scheme_host_port);
if (!const_cast<URLSecurityManagerWin*>(this)->EnsureSystemSecurityManager())
return false;
std::u16string url16 = base::ASCIIToUTF16(auth_scheme_host_port.Serialize());
DWORD policy = 0;
HRESULT hr;
hr = security_manager_->ProcessUrlAction(
base::as_wcstr(url16), URLACTION_CREDENTIALS_USE,
reinterpret_cast<BYTE*>(&policy), sizeof(policy), nullptr, 0, PUAF_NOUI,
0);
if (FAILED(hr)) {
LOG(ERROR) << "IInternetSecurityManager::ProcessUrlAction failed: " << hr;
return false;
}
// Four possible policies for URLACTION_CREDENTIALS_USE. See the MSDN page
// "About URL Security Zones" at
// http://msdn.microsoft.com/en-us/library/ms537183(VS.85).aspx
switch (policy) {
case URLPOLICY_CREDENTIALS_SILENT_LOGON_OK:
return true;
case URLPOLICY_CREDENTIALS_CONDITIONAL_PROMPT: {
// This policy means "prompt the user for permission if the resource is
// not located in the Intranet zone". TODO(wtc): Note that it's
// prompting for permission (to use the default credentials), as opposed
// to prompting the user to enter a user name and password.
// URLZONE_LOCAL_MACHINE 0
// URLZONE_INTRANET 1
// URLZONE_TRUSTED 2
// URLZONE_INTERNET 3
// URLZONE_UNTRUSTED 4
DWORD zone = 0;
hr = security_manager_->MapUrlToZone(base::as_wcstr(url16), &zone, 0);
if (FAILED(hr)) {
LOG(ERROR) << "IInternetSecurityManager::MapUrlToZone failed: " << hr;
return false;
}
return zone <= URLZONE_INTRANET;
}
case URLPOLICY_CREDENTIALS_MUST_PROMPT_USER:
return false;
case URLPOLICY_CREDENTIALS_ANONYMOUS_ONLY:
// TODO(wtc): we should fail the authentication.
return false;
default:
NOTREACHED();
return false;
}
}
// TODO(cbentzel): Could CanDelegate use the security zone as well?
bool URLSecurityManagerWin::EnsureSystemSecurityManager() {
if (!security_manager_.Get()) {
HRESULT hr =
CoInternetCreateSecurityManager(nullptr, &security_manager_, 0);
if (FAILED(hr) || !security_manager_.Get()) {
LOG(ERROR) << "Unable to create the Windows Security Manager instance";
return false;
}
}
return true;
}
// static
std::unique_ptr<URLSecurityManager> URLSecurityManager::Create() {
return std::make_unique<URLSecurityManagerWin>();
}
} // namespace net
|
