Support Kerberos on Android

net/http/http_auth_handler_negotiate_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "net/http/http_auth_handler_negotiate.h"
 
+#include <string>
+
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_request_info.h"
 #include "net/http/mock_allow_url_security_manager.h"
-#if defined(OS_WIN)
+#if defined(OS_ANDROID)
+#include "net/android/dummy_spnego_authenticator.h"
+#elif defined(OS_WIN)
 #include "net/http/mock_sspi_library_win.h"
 #elif defined(OS_POSIX)
 #include "net/http/mock_gssapi_library_posix.h"
 #endif
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
-#if defined(OS_WIN)
+#if defined(OS_ANDROID)
+typedef net::android::DummySpnegoAuthenticator MockAuthLibrary;
+#elif defined(OS_WIN)
 typedef MockSSPILibrary MockAuthLibrary;
 #elif defined(OS_POSIX)
 typedef test::MockGSSAPILibrary MockAuthLibrary;
 #endif
 
 class HttpAuthHandlerNegotiateTest : public PlatformTest {
  public:
   void SetUp() override {
     auth_library_ = new MockAuthLibrary();
     resolver_.reset(new MockHostResolver());
     resolver_->rules()->AddIPLiteralRule("alias", "10.0.0.2",
                                            "canonical.example.com");
 
     url_security_manager_.reset(new MockAllowURLSecurityManager());
     factory_.reset(new HttpAuthHandlerNegotiate::Factory());
     factory_->set_url_security_manager(url_security_manager_.get());
+#if defined(OS_ANDROID)
+    std::string* authenticator =
+        new std::string("org.chromium.test.DummySpnegoAuthenticator");
+    factory_->set_library(authenticator);
+    MockAuthLibrary::EnsureTestAccountExists();
+#endif
+#if defined(OS_WIN) || (defined(OS_POSIX) && !defined(OS_ANDROID))
     factory_->set_library(auth_library_);
+#endif
     factory_->set_host_resolver(resolver_.get());
   }
 
+#if defined(OS_ANDROID)
+  void TearDown() override { MockAuthLibrary::RemoveTestAccounts(); }
+#endif
+
   void SetupMocks(MockAuthLibrary* mock_library) {
 #if defined(OS_WIN)
     security_package_.reset(new SecPkgInfoW);
     memset(security_package_.get(), 0x0, sizeof(SecPkgInfoW));
     security_package_->cbMaxToken = 1337;
     mock_library->ExpectQuerySecurityPackageInfo(
         L"Negotiate", SEC_E_OK, security_package_.get());
 #elif defined(OS_POSIX)
     // Copied from an actual transaction!
     static const char kAuthResponse[] =
@@ skipping 51 matching lines @@
         1,                                   // Locally initiated
         0);                                  // Open
     test::GssContextMockImpl context2(
         "localhost",                         // Source name
         "example.com",                       // Target name
         23,                                  // Lifetime
         *CHROME_GSS_SPNEGO_MECH_OID_DESC,    // Mechanism
         0,                                   // Context flags
         1,                                   // Locally initiated
         1);                                  // Open
-    test::MockGSSAPILibrary::SecurityContextQuery queries[] = {
-    test::MockGSSAPILibrary::SecurityContextQuery(
-        "Negotiate",                    // Package name
-        GSS_S_CONTINUE_NEEDED,          // Major response code
-        0,                              // Minor response code
-        context1,                       // Context
-        NULL,                           // Expected input token
-        kAuthResponse),                 // Output token
-    test::MockGSSAPILibrary::SecurityContextQuery(
-        "Negotiate",                    // Package name
-        GSS_S_COMPLETE,                 // Major response code
-        0,                              // Minor response code
-        context2,                       // Context
-        kAuthResponse,                  // Expected input token
-        kAuthResponse)                  // Output token
+    MockAuthLibrary::SecurityContextQuery queries[] = {
+        MockAuthLibrary::SecurityContextQuery(
+            "Negotiate",            // Package name
+            GSS_S_CONTINUE_NEEDED,  // Major response code
+            0,                      // Minor response code
+            context1,               // Context
+            NULL,                   // Expected input token
+            kAuthResponse),         // Output token
+        MockAuthLibrary::SecurityContextQuery(
+            "Negotiate",     // Package name
+            GSS_S_COMPLETE,  // Major response code
+            0,               // Minor response code
+            context2,        // Context
+            kAuthResponse,   // Expected input token
+            kAuthResponse)   // Output token
     };
 
     for (size_t i = 0; i < arraysize(queries); ++i) {
       mock_library->ExpectSecurityContext(queries[i].expected_package,
                                           queries[i].response_code,
                                           queries[i].minor_response_code,
                                           queries[i].context_info,
                                           queries[i].expected_input_token,
                                           queries[i].output_token);
     }
 #endif  // defined(OS_POSIX)
   }
 
 #if defined(OS_POSIX)
   void SetupErrorMocks(MockAuthLibrary* mock_library,
                        int major_status,
                        int minor_status) {
     const gss_OID_desc kDefaultMech = { 0, NULL };
     test::GssContextMockImpl context(
         "localhost",                    // Source name
         "example.com",                  // Target name
         0,                              // Lifetime
         kDefaultMech,                   // Mechanism
         0,                              // Context flags
         1,                              // Locally initiated
         0);                             // Open
-    test::MockGSSAPILibrary::SecurityContextQuery query(
-        "Negotiate",                    // Package name
-        major_status,                   // Major response code
-        minor_status,                   // Minor response code
-        context,                        // Context
-        NULL,                           // Expected input token
-        NULL);                          // Output token
+    MockAuthLibrary::SecurityContextQuery query(
+        "Negotiate",   // Package name
+        major_status,  // Major response code
+        minor_status,  // Minor response code
+        context,       // Context
+        NULL,          // Expected input token
+        NULL);         // Output token
 
     mock_library->ExpectSecurityContext(query.expected_package,
                                         query.response_code,
                                         query.minor_response_code,
                                         query.context_info,
                                         query.expected_input_token,
                                         query.output_token);
   }
 
 #endif  // defined(OS_POSIX)
@@ skipping 42 matching lines @@
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCname) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       true, false, true, "http://alias:500", &auth_handler));
 
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK, callback.GetResult(auth_handler->GenerateAuthToken(
+                    NULL, &request_info, callback.callback(), &token)));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/alias", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@alias", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameStandardPort) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       true, true, true, "http://alias:80", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK, callback.GetResult(auth_handler->GenerateAuthToken(
+                    NULL, &request_info, callback.callback(), &token)));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/alias", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@alias", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameNonstandardPort) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       true, true, true, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK, callback.GetResult(auth_handler->GenerateAuthToken(
+                    NULL, &request_info, callback.callback(), &token)));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/alias:500", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@alias:500", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, CnameSync) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       false, false, true, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK, callback.GetResult(auth_handler->GenerateAuthToken(
+                    NULL, &request_info, callback.callback(), &token)));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/canonical.example.com", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@canonical.example.com", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, CnameAsync) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
@@ skipping 67 matching lines @@
       BoundNetLog(),
       &generic_handler);
   EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv);
   EXPECT_TRUE(generic_handler.get() == NULL);
 }
 #endif  // defined(DLOPEN_KERBEROS)
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace net