Kerberos SPN generation for Negotiate challenges

net/http/http_auth_sspi_win.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // See "SSPI Sample Application" at
 // http://msdn.microsoft.com/en-us/library/aa918273.aspx
 
 #include "net/http/http_auth_sspi_win.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
-#include "net/base/net_util.h"
 #include "net/http/http_auth.h"
 
 namespace net {
 
 namespace {
 
 int MapAcquireCredentialsStatusToError(SECURITY_STATUS status,
                                        const SEC_WCHAR* package) {
   switch (status) {
     case SEC_E_OK:
@@ skipping 129 matching lines @@
   if (!base64_rv) {
     LOG(ERROR) << "Base64 decoding of auth token failed.";
     return false;
   }
   decoded_server_auth_token_ = decoded_auth_token;
   return true;
 }
 
 int HttpAuthSSPI::GenerateAuthToken(const std::wstring* username,
                                     const std::wstring* password,
-                                    const GURL& origin,
+                                    const std::wstring& spn,
                                     const HttpRequestInfo* request,
                                     const ProxyInfo* proxy,
                                     std::string* auth_token) {
   DCHECK((username == NULL) == (password == NULL));
 
   // Initial challenge.
   if (!IsFinalRound()) {
     int rv = OnFirstRound(username, password);
     if (rv != OK)
       return rv;
   }
 
   void* out_buf;
   int out_buf_len;
   int rv = GetNextSecurityToken(
-      origin,
+      spn,
       static_cast<void *>(const_cast<char *>(
           decoded_server_auth_token_.c_str())),
       decoded_server_auth_token_.length(),
       &out_buf,
       &out_buf_len);
   if (rv != OK)
     return rv;
 
   // Base64 encode data in output buffer and prepend the scheme.
   std::string encode_input(static_cast<char*>(out_buf), out_buf_len);
@@ skipping 24 matching lines @@
   } else {
     rv = AcquireDefaultCredentials(library_, security_package_, &cred_);
     if (rv != OK)
       return rv;
   }
 
   return rv;
 }
 
 int HttpAuthSSPI::GetNextSecurityToken(
-    const GURL& origin,
+    const std::wstring& spn,
     const void * in_token,
     int in_token_len,
     void** out_token,
     int* out_token_len) {
   SECURITY_STATUS status;
   TimeStamp expiry;
 
   DWORD ctxt_attr;
   CtxtHandle* ctxt_ptr;
   SecBufferDesc in_buffer_desc, out_buffer_desc;
@@ skipping 25 matching lines @@
   // Prepare output buffer.
   out_buffer_desc.ulVersion = SECBUFFER_VERSION;
   out_buffer_desc.cBuffers = 1;
   out_buffer_desc.pBuffers = &out_buffer;
   out_buffer.BufferType = SECBUFFER_TOKEN;
   out_buffer.cbBuffer = max_token_length_;
   out_buffer.pvBuffer = malloc(out_buffer.cbBuffer);
   if (!out_buffer.pvBuffer)
     return ERR_OUT_OF_MEMORY;
 
-  // The service principal name of the destination server.  See
-  // http://msdn.microsoft.com/en-us/library/ms677949%28VS.85%29.aspx
-  std::wstring target(L"HTTP/");
-  target.append(ASCIIToWide(GetHostAndPort(origin)));
-  wchar_t* target_name = const_cast<wchar_t*>(target.c_str());
-
   // This returns a token that is passed to the remote server.
   status = library_->InitializeSecurityContext(
       &cred_,  // phCredential
       ctxt_ptr,  // phContext
-      target_name,  // pszTargetName
+      const_cast<wchar_t *>(spn.c_str()),  // pszTargetName
       0,  // fContextReq
       0,  // Reserved1 (must be 0)
       SECURITY_NATIVE_DREP,  // TargetDataRep
       in_buffer_desc_ptr,  // pInput
       0,  // Reserved2 (must be 0)
       &ctxt_,  // phNewContext
       &out_buffer_desc,  // pOutput
       &ctxt_attr,  // pfContextAttr
       &expiry);  // ptsExpiry
   // On success, the function returns SEC_I_CONTINUE_NEEDED on the first call
@@ skipping 125 matching lines @@
  private:
   friend struct DefaultSingletonTraits<SSPILibraryDefault>;
 };
 
 // static
 SSPILibrary* SSPILibrary::GetDefault() {
   return Singleton<SSPILibraryDefault>::get();
 }
 
 }  // namespace net