Kerberos SPN generation for Negotiate challenges

net/http/http_auth_sspi_win.h

 // 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.
 
 // This file contains common routines used by NTLM and Negotiate authentication
 // using the SSPI API on Windows.
 
 #ifndef NET_HTTP_HTTP_AUTH_SSPI_WIN_H_
 #define NET_HTTP_HTTP_AUTH_SSPI_WIN_H_
 
 // security.h needs to be included for CredHandle. Unfortunately CredHandle
 // is a typedef and can't be forward declared.
 #define SECURITY_WIN32 1
 #include <windows.h>
 #include <security.h>
 
 #include <string>
 
 #include "net/http/http_auth.h"
 
-class GURL;
-
 namespace net {
 
 class HttpRequestInfo;
 class ProxyInfo;
 
 // SSPILibrary is introduced so unit tests can mock the calls to Windows' SSPI
 // implementation. The default implementation simply passes the arguments on to
 // the SSPI implementation provided by Secur32.dll.
 // NOTE(cbentzel): I considered replacing the Secur32.dll with a mock DLL, but
 // decided that it wasn't worth the effort as this is unlikely to be performance
@@ skipping 49 matching lines @@
   ~HttpAuthSSPI();
 
   bool NeedsIdentity() const;
   bool IsFinalRound() const;
 
   bool ParseChallenge(HttpAuth::ChallengeTokenizer* tok);
 
   // Generates an authentication token.
   // The return value is an error code. If it's not |OK|, the value of
   // |*auth_token| is unspecified.
+  // |spn| is the Service Principal Name of the server that the token is
+  // being generated for.
   // If this is the first round of a multiple round scheme, credentials are
   // obtained using |*username| and |*password|. If |username| and |password|
   // are NULL, the default credentials are used instead.
   int 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);
 
  private:
   int OnFirstRound(const std::wstring* username,
                    const std::wstring* password);
 
   int GetNextSecurityToken(
-      const GURL& origin,
+      const std::wstring& spn,
       const void* in_token,
       int in_token_len,
       void** out_token,
       int* out_token_len);
 
   void ResetSecurityContext();
 
   SSPILibrary* library_;
   std::string scheme_;
   SEC_WCHAR* security_package_;
@@ skipping 28 matching lines @@
 // in the underlying SSPI call. The details are logged, and |*max_token_length|
 // is not changed.
 int DetermineMaxTokenLength(SSPILibrary* library,
                             const std::wstring& package,
                             ULONG* max_token_length);
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_AUTH_SSPI_WIN_H_