1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/http/http_auth_handler_factory.h"
6
7 #include "base/stl_util-inl.h"
8 #include "base/string_util.h"
9 #include "net/base/net_errors.h"
10 #include "net/http/http_auth_filter.h"
11 #include "net/http/http_auth_handler_basic.h"
12 #include "net/http/http_auth_handler_digest.h"
13 #include "net/http/http_auth_handler_negotiate.h"
14 #include "net/http/http_auth_handler_ntlm.h"
15
16 namespace net {
17
CreateAuthHandlerFromString(const std::string & challenge,HttpAuth::Target target,const GURL & origin,const BoundNetLog & net_log,scoped_ptr<HttpAuthHandler> * handler)18 int HttpAuthHandlerFactory::CreateAuthHandlerFromString(
19 const std::string& challenge,
20 HttpAuth::Target target,
21 const GURL& origin,
22 const BoundNetLog& net_log,
23 scoped_ptr<HttpAuthHandler>* handler) {
24 HttpAuth::ChallengeTokenizer props(challenge.begin(), challenge.end());
25 return CreateAuthHandler(&props, target, origin, CREATE_CHALLENGE, 1,
26 net_log, handler);
27 }
28
CreatePreemptiveAuthHandlerFromString(const std::string & challenge,HttpAuth::Target target,const GURL & origin,int digest_nonce_count,const BoundNetLog & net_log,scoped_ptr<HttpAuthHandler> * handler)29 int HttpAuthHandlerFactory::CreatePreemptiveAuthHandlerFromString(
30 const std::string& challenge,
31 HttpAuth::Target target,
32 const GURL& origin,
33 int digest_nonce_count,
34 const BoundNetLog& net_log,
35 scoped_ptr<HttpAuthHandler>* handler) {
36 HttpAuth::ChallengeTokenizer props(challenge.begin(), challenge.end());
37 return CreateAuthHandler(&props, target, origin, CREATE_PREEMPTIVE,
38 digest_nonce_count, net_log, handler);
39 }
40
41 // static
CreateDefault(HostResolver * host_resolver)42 HttpAuthHandlerRegistryFactory* HttpAuthHandlerFactory::CreateDefault(
43 HostResolver* host_resolver) {
44 DCHECK(host_resolver);
45 HttpAuthHandlerRegistryFactory* registry_factory =
46 new HttpAuthHandlerRegistryFactory();
47 registry_factory->RegisterSchemeFactory(
48 "basic", new HttpAuthHandlerBasic::Factory());
49 registry_factory->RegisterSchemeFactory(
50 "digest", new HttpAuthHandlerDigest::Factory());
51
52 HttpAuthHandlerNegotiate::Factory* negotiate_factory =
53 new HttpAuthHandlerNegotiate::Factory();
54 #if defined(OS_POSIX)
55 negotiate_factory->set_library(new GSSAPISharedLibrary(std::string()));
56 #elif defined(OS_WIN)
57 negotiate_factory->set_library(new SSPILibraryDefault());
58 #endif
59 negotiate_factory->set_host_resolver(host_resolver);
60 registry_factory->RegisterSchemeFactory("negotiate", negotiate_factory);
61
62 HttpAuthHandlerNTLM::Factory* ntlm_factory =
63 new HttpAuthHandlerNTLM::Factory();
64 #if defined(OS_WIN)
65 ntlm_factory->set_sspi_library(new SSPILibraryDefault());
66 #endif
67 registry_factory->RegisterSchemeFactory("ntlm", ntlm_factory);
68 return registry_factory;
69 }
70
71 namespace {
72
IsSupportedScheme(const std::vector<std::string> & supported_schemes,const std::string & scheme)73 bool IsSupportedScheme(const std::vector<std::string>& supported_schemes,
74 const std::string& scheme) {
75 std::vector<std::string>::const_iterator it = std::find(
76 supported_schemes.begin(), supported_schemes.end(), scheme);
77 return it != supported_schemes.end();
78 }
79
80 } // namespace
81
HttpAuthHandlerRegistryFactory()82 HttpAuthHandlerRegistryFactory::HttpAuthHandlerRegistryFactory() {
83 }
84
~HttpAuthHandlerRegistryFactory()85 HttpAuthHandlerRegistryFactory::~HttpAuthHandlerRegistryFactory() {
86 STLDeleteContainerPairSecondPointers(factory_map_.begin(),
87 factory_map_.end());
88 }
89
SetURLSecurityManager(const std::string & scheme,URLSecurityManager * security_manager)90 void HttpAuthHandlerRegistryFactory::SetURLSecurityManager(
91 const std::string& scheme,
92 URLSecurityManager* security_manager) {
93 HttpAuthHandlerFactory* factory = GetSchemeFactory(scheme);
94 if (factory)
95 factory->set_url_security_manager(security_manager);
96 }
97
RegisterSchemeFactory(const std::string & scheme,HttpAuthHandlerFactory * factory)98 void HttpAuthHandlerRegistryFactory::RegisterSchemeFactory(
99 const std::string& scheme,
100 HttpAuthHandlerFactory* factory) {
101 std::string lower_scheme = StringToLowerASCII(scheme);
102 FactoryMap::iterator it = factory_map_.find(lower_scheme);
103 if (it != factory_map_.end()) {
104 delete it->second;
105 }
106 if (factory)
107 factory_map_[lower_scheme] = factory;
108 else
109 factory_map_.erase(it);
110 }
111
GetSchemeFactory(const std::string & scheme) const112 HttpAuthHandlerFactory* HttpAuthHandlerRegistryFactory::GetSchemeFactory(
113 const std::string& scheme) const {
114 std::string lower_scheme = StringToLowerASCII(scheme);
115 FactoryMap::const_iterator it = factory_map_.find(lower_scheme);
116 if (it == factory_map_.end()) {
117 return NULL; // |scheme| is not registered.
118 }
119 return it->second;
120 }
121
122 // static
Create(const std::vector<std::string> & supported_schemes,URLSecurityManager * security_manager,HostResolver * host_resolver,const std::string & gssapi_library_name,bool negotiate_disable_cname_lookup,bool negotiate_enable_port)123 HttpAuthHandlerRegistryFactory* HttpAuthHandlerRegistryFactory::Create(
124 const std::vector<std::string>& supported_schemes,
125 URLSecurityManager* security_manager,
126 HostResolver* host_resolver,
127 const std::string& gssapi_library_name,
128 bool negotiate_disable_cname_lookup,
129 bool negotiate_enable_port) {
130 HttpAuthHandlerRegistryFactory* registry_factory =
131 new HttpAuthHandlerRegistryFactory();
132 if (IsSupportedScheme(supported_schemes, "basic"))
133 registry_factory->RegisterSchemeFactory(
134 "basic", new HttpAuthHandlerBasic::Factory());
135 if (IsSupportedScheme(supported_schemes, "digest"))
136 registry_factory->RegisterSchemeFactory(
137 "digest", new HttpAuthHandlerDigest::Factory());
138 if (IsSupportedScheme(supported_schemes, "ntlm")) {
139 HttpAuthHandlerNTLM::Factory* ntlm_factory =
140 new HttpAuthHandlerNTLM::Factory();
141 ntlm_factory->set_url_security_manager(security_manager);
142 #if defined(OS_WIN)
143 ntlm_factory->set_sspi_library(new SSPILibraryDefault());
144 #endif
145 registry_factory->RegisterSchemeFactory("ntlm", ntlm_factory);
146 }
147 if (IsSupportedScheme(supported_schemes, "negotiate")) {
148 HttpAuthHandlerNegotiate::Factory* negotiate_factory =
149 new HttpAuthHandlerNegotiate::Factory();
150 #if defined(OS_POSIX)
151 negotiate_factory->set_library(
152 new GSSAPISharedLibrary(gssapi_library_name));
153 #elif defined(OS_WIN)
154 negotiate_factory->set_library(new SSPILibraryDefault());
155 #endif
156 negotiate_factory->set_url_security_manager(security_manager);
157 DCHECK(host_resolver || negotiate_disable_cname_lookup);
158 negotiate_factory->set_host_resolver(host_resolver);
159 negotiate_factory->set_disable_cname_lookup(negotiate_disable_cname_lookup);
160 negotiate_factory->set_use_port(negotiate_enable_port);
161 registry_factory->RegisterSchemeFactory("negotiate", negotiate_factory);
162 }
163
164 return registry_factory;
165 }
166
CreateAuthHandler(HttpAuth::ChallengeTokenizer * challenge,HttpAuth::Target target,const GURL & origin,CreateReason reason,int digest_nonce_count,const BoundNetLog & net_log,scoped_ptr<HttpAuthHandler> * handler)167 int HttpAuthHandlerRegistryFactory::CreateAuthHandler(
168 HttpAuth::ChallengeTokenizer* challenge,
169 HttpAuth::Target target,
170 const GURL& origin,
171 CreateReason reason,
172 int digest_nonce_count,
173 const BoundNetLog& net_log,
174 scoped_ptr<HttpAuthHandler>* handler) {
175 std::string scheme = challenge->scheme();
176 if (scheme.empty()) {
177 handler->reset();
178 return ERR_INVALID_RESPONSE;
179 }
180 std::string lower_scheme = StringToLowerASCII(scheme);
181 FactoryMap::iterator it = factory_map_.find(lower_scheme);
182 if (it == factory_map_.end()) {
183 handler->reset();
184 return ERR_UNSUPPORTED_AUTH_SCHEME;
185 }
186 DCHECK(it->second);
187 return it->second->CreateAuthHandler(challenge, target, origin, reason,
188 digest_nonce_count, net_log, handler);
189 }
190
191 } // namespace net
192