chrome/browser/safe_browsing/client_side_detection_service_unittest.cc

   1 // Copyright (c) 2012 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 <map>
   6 #include <queue>
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/time/time.h"
  15 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
  16 #include "chrome/common/safe_browsing/client_model.pb.h"
  17 #include "chrome/common/safe_browsing/csd.pb.h"
  18 #include "content/public/test/test_browser_thread.h"
  19 #include "crypto/sha2.h"
  20 #include "net/http/http_status_code.h"
  21 #include "net/url_request/test_url_fetcher_factory.h"
  22 #include "net/url_request/url_request_status.h"
  23 #include "testing/gmock/include/gmock/gmock.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "url/gurl.h"
  26
  27 using ::testing::Invoke;
  28 using ::testing::Mock;
  29 using ::testing::StrictMock;
  30 using ::testing::_;
  31 using content::BrowserThread;
  32
  33 namespace safe_browsing {
  34 namespace {
  35 class MockClientSideDetectionService : public ClientSideDetectionService {
  36  public:
  37   MockClientSideDetectionService() : ClientSideDetectionService(NULL) {}
  38   virtual ~MockClientSideDetectionService() {}
  39
  40   MOCK_METHOD1(EndFetchModel, void(ClientModelStatus));
  41   MOCK_METHOD1(ScheduleFetchModel, void(int64));
  42
  43   void Schedule(int64) {
  44     // Ignore the delay when testing.
  45     StartFetchModel();
  46   }
  47
  48   void Disable(int) {
  49     // Ignore the status.
  50     SetEnabledAndRefreshState(false);
  51   }
  52
  53  private:
  54   DISALLOW_COPY_AND_ASSIGN(MockClientSideDetectionService);
  55 };
  56
  57 ACTION(QuitCurrentMessageLoop) {
  58   base::MessageLoop::current()->Quit();
  59 }
  60
  61 }  // namespace
  62
  63 class ClientSideDetectionServiceTest : public testing::Test {
  64  protected:
  65   virtual void SetUp() {
  66     file_thread_.reset(new content::TestBrowserThread(BrowserThread::FILE,
  67                                                       &msg_loop_));
  68
  69     factory_.reset(new net::FakeURLFetcherFactory(NULL));
  70
  71     browser_thread_.reset(new content::TestBrowserThread(BrowserThread::UI,
  72                                                          &msg_loop_));
  73   }
  74
  75   virtual void TearDown() {
  76     msg_loop_.RunUntilIdle();
  77     csd_service_.reset();
  78     file_thread_.reset();
  79     browser_thread_.reset();
  80   }
  81
  82   bool SendClientReportPhishingRequest(const GURL& phishing_url,
  83                                        float score) {
  84     ClientPhishingRequest* request = new ClientPhishingRequest();
  85     request->set_url(phishing_url.spec());
  86     request->set_client_score(score);
  87     request->set_is_phishing(true);  // client thinks the URL is phishing.
  88     csd_service_->SendClientReportPhishingRequest(
  89         request,
  90         base::Bind(&ClientSideDetectionServiceTest::SendRequestDone,
  91                    base::Unretained(this)));
  92     phishing_url_ = phishing_url;
  93     msg_loop_.Run();  // Waits until callback is called.
  94     return is_phishing_;
  95   }
  96
  97   bool SendClientReportMalwareRequest(const GURL& url) {
  98     scoped_ptr<ClientMalwareRequest> request(new ClientMalwareRequest());
  99     request->set_url(url.spec());
 100     csd_service_->SendClientReportMalwareRequest(
 101         request.release(),
 102         base::Bind(&ClientSideDetectionServiceTest::SendMalwareRequestDone,
 103                    base::Unretained(this)));
 104     phishing_url_ = url;
 105     msg_loop_.Run();  // Waits until callback is called.
 106     return is_malware_;
 107   }
 108
 109   void SetModelFetchResponse(std::string response_data,
 110                              net::HttpStatusCode response_code,
 111                              net::URLRequestStatus::Status status) {
 112     factory_->SetFakeResponse(GURL(ClientSideDetectionService::kClientModelUrl),
 113                               response_data, response_code, status);
 114   }
 115
 116   void SetClientReportPhishingResponse(std::string response_data,
 117                                        net::HttpStatusCode response_code,
 118                                        net::URLRequestStatus::Status status) {
 119     factory_->SetFakeResponse(
 120         ClientSideDetectionService::GetClientReportUrl(
 121             ClientSideDetectionService::kClientReportPhishingUrl),
 122         response_data, response_code, status);
 123   }
 124
 125   void SetClientReportMalwareResponse(std::string response_data,
 126                                       net::HttpStatusCode response_code,
 127                                       net::URLRequestStatus::Status status) {
 128     factory_->SetFakeResponse(
 129         ClientSideDetectionService::GetClientReportUrl(
 130             ClientSideDetectionService::kClientReportMalwareUrl),
 131         response_data, response_code, status);
 132   }
 133
 134   int GetNumReports(std::queue<base::Time>* report_times) {
 135     return csd_service_->GetNumReports(report_times);
 136   }
 137
 138   std::queue<base::Time>& GetPhishingReportTimes() {
 139     return csd_service_->phishing_report_times_;
 140   }
 141
 142   std::queue<base::Time>& GetMalwareReportTimes() {
 143     return csd_service_->malware_report_times_;
 144   }
 145
 146   void SetCache(const GURL& gurl, bool is_phishing, base::Time time) {
 147     csd_service_->cache_[gurl] =
 148         make_linked_ptr(new ClientSideDetectionService::CacheState(is_phishing,
 149                                                                    time));
 150   }
 151
 152   void TestCache() {
 153     ClientSideDetectionService::PhishingCache& cache = csd_service_->cache_;
 154     base::Time now = base::Time::Now();
 155     base::Time time =
 156         now - base::TimeDelta::FromDays(
 157             ClientSideDetectionService::kNegativeCacheIntervalDays) +
 158         base::TimeDelta::FromMinutes(5);
 159     cache[GURL("http://first.url.com/")] =
 160         make_linked_ptr(new ClientSideDetectionService::CacheState(false,
 161                                                                    time));
 162
 163     time =
 164         now - base::TimeDelta::FromDays(
 165             ClientSideDetectionService::kNegativeCacheIntervalDays) -
 166         base::TimeDelta::FromHours(1);
 167     cache[GURL("http://second.url.com/")] =
 168         make_linked_ptr(new ClientSideDetectionService::CacheState(false,
 169                                                                    time));
 170
 171     time =
 172         now - base::TimeDelta::FromMinutes(
 173             ClientSideDetectionService::kPositiveCacheIntervalMinutes) -
 174         base::TimeDelta::FromMinutes(5);
 175     cache[GURL("http://third.url.com/")] =
 176         make_linked_ptr(new ClientSideDetectionService::CacheState(true, time));
 177
 178     time =
 179         now - base::TimeDelta::FromMinutes(
 180             ClientSideDetectionService::kPositiveCacheIntervalMinutes) +
 181         base::TimeDelta::FromMinutes(5);
 182     cache[GURL("http://fourth.url.com/")] =
 183         make_linked_ptr(new ClientSideDetectionService::CacheState(true, time));
 184
 185     csd_service_->UpdateCache();
 186
 187     // 3 elements should be in the cache, the first, third, and fourth.
 188     EXPECT_EQ(3U, cache.size());
 189     EXPECT_TRUE(cache.find(GURL("http://first.url.com/")) != cache.end());
 190     EXPECT_TRUE(cache.find(GURL("http://third.url.com/")) != cache.end());
 191     EXPECT_TRUE(cache.find(GURL("http://fourth.url.com/")) != cache.end());
 192
 193     // While 3 elements remain, only the first and the fourth are actually
 194     // valid.
 195     bool is_phishing;
 196     EXPECT_TRUE(csd_service_->GetValidCachedResult(
 197         GURL("http://first.url.com"), &is_phishing));
 198     EXPECT_FALSE(is_phishing);
 199     EXPECT_FALSE(csd_service_->GetValidCachedResult(
 200         GURL("http://third.url.com"), &is_phishing));
 201     EXPECT_TRUE(csd_service_->GetValidCachedResult(
 202         GURL("http://fourth.url.com"), &is_phishing));
 203     EXPECT_TRUE(is_phishing);
 204   }
 205
 206   void AddFeature(const std::string& name, double value,
 207                   ClientPhishingRequest* request) {
 208     ClientPhishingRequest_Feature* feature = request->add_feature_map();
 209     feature->set_name(name);
 210     feature->set_value(value);
 211   }
 212
 213   void AddNonModelFeature(const std::string& name, double value,
 214                           ClientPhishingRequest* request) {
 215     ClientPhishingRequest_Feature* feature =
 216         request->add_non_model_feature_map();
 217     feature->set_name(name);
 218     feature->set_value(value);
 219   }
 220
 221   void CheckConfirmedMalwareUrl(GURL url) {
 222     ASSERT_EQ(confirmed_malware_url_, url);
 223   }
 224
 225  protected:
 226   scoped_ptr<ClientSideDetectionService> csd_service_;
 227   scoped_ptr<net::FakeURLFetcherFactory> factory_;
 228   base::MessageLoop msg_loop_;
 229
 230  private:
 231   void SendRequestDone(GURL phishing_url, bool is_phishing) {
 232     ASSERT_EQ(phishing_url, phishing_url_);
 233     is_phishing_ = is_phishing;
 234     msg_loop_.Quit();
 235   }
 236
 237   void SendMalwareRequestDone(GURL original_url, GURL malware_url,
 238                               bool is_malware) {
 239     ASSERT_EQ(phishing_url_, original_url);
 240     confirmed_malware_url_ = malware_url;
 241     is_malware_ = is_malware;
 242     msg_loop_.Quit();
 243   }
 244
 245   scoped_ptr<content::TestBrowserThread> browser_thread_;
 246   scoped_ptr<content::TestBrowserThread> file_thread_;
 247
 248   GURL phishing_url_;
 249   GURL confirmed_malware_url_;
 250   bool is_phishing_;
 251   bool is_malware_;
 252 };
 253
 254 TEST_F(ClientSideDetectionServiceTest, FetchModelTest) {
 255   // We don't want to use a real service class here because we can't call
 256   // the real EndFetchModel.  It would reschedule a reload which might
 257   // make the test flaky.
 258   MockClientSideDetectionService service;
 259   EXPECT_CALL(service, ScheduleFetchModel(_)).Times(1);
 260   service.SetEnabledAndRefreshState(true);
 261
 262   // The model fetch failed.
 263   SetModelFetchResponse("blamodel", net::HTTP_INTERNAL_SERVER_ERROR,
 264                         net::URLRequestStatus::FAILED);
 265   EXPECT_CALL(service, EndFetchModel(
 266       ClientSideDetectionService::MODEL_FETCH_FAILED))
 267       .WillOnce(QuitCurrentMessageLoop());
 268   service.StartFetchModel();
 269   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 270   Mock::VerifyAndClearExpectations(&service);
 271
 272   // Empty model file.
 273   SetModelFetchResponse(std::string(), net::HTTP_OK,
 274                         net::URLRequestStatus::SUCCESS);
 275   EXPECT_CALL(service, EndFetchModel(ClientSideDetectionService::MODEL_EMPTY))
 276       .WillOnce(QuitCurrentMessageLoop());
 277   service.StartFetchModel();
 278   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 279   Mock::VerifyAndClearExpectations(&service);
 280
 281   // Model is too large.
 282   SetModelFetchResponse(
 283       std::string(ClientSideDetectionService::kMaxModelSizeBytes + 1, 'x'),
 284       net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 285   EXPECT_CALL(service, EndFetchModel(
 286       ClientSideDetectionService::MODEL_TOO_LARGE))
 287       .WillOnce(QuitCurrentMessageLoop());
 288   service.StartFetchModel();
 289   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 290   Mock::VerifyAndClearExpectations(&service);
 291
 292   // Unable to parse the model file.
 293   SetModelFetchResponse("Invalid model file", net::HTTP_OK,
 294                         net::URLRequestStatus::SUCCESS);
 295   EXPECT_CALL(service, EndFetchModel(
 296       ClientSideDetectionService::MODEL_PARSE_ERROR))
 297       .WillOnce(QuitCurrentMessageLoop());
 298   service.StartFetchModel();
 299   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 300   Mock::VerifyAndClearExpectations(&service);
 301
 302   // Model that is missing some required fields (missing the version field).
 303   ClientSideModel model;
 304   model.set_max_words_per_term(4);
 305   SetModelFetchResponse(model.SerializePartialAsString(), net::HTTP_OK,
 306                         net::URLRequestStatus::SUCCESS);
 307   EXPECT_CALL(service, EndFetchModel(
 308       ClientSideDetectionService::MODEL_MISSING_FIELDS))
 309       .WillOnce(QuitCurrentMessageLoop());
 310   service.StartFetchModel();
 311   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 312   Mock::VerifyAndClearExpectations(&service);
 313
 314   // Model that points to hashes that don't exist.
 315   model.set_version(10);
 316   model.add_hashes("bla");
 317   model.add_page_term(1);  // Should be 0 instead of 1.
 318   SetModelFetchResponse(model.SerializePartialAsString(), net::HTTP_OK,
 319                         net::URLRequestStatus::SUCCESS);
 320   EXPECT_CALL(service, EndFetchModel(
 321       ClientSideDetectionService::MODEL_BAD_HASH_IDS))
 322       .WillOnce(QuitCurrentMessageLoop());
 323   service.StartFetchModel();
 324   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 325   Mock::VerifyAndClearExpectations(&service);
 326   model.set_page_term(0, 0);
 327
 328   // Model version number is wrong.
 329   model.set_version(-1);
 330   SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
 331                         net::URLRequestStatus::SUCCESS);
 332   EXPECT_CALL(service, EndFetchModel(
 333       ClientSideDetectionService::MODEL_INVALID_VERSION_NUMBER))
 334       .WillOnce(QuitCurrentMessageLoop());
 335   service.StartFetchModel();
 336   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 337   Mock::VerifyAndClearExpectations(&service);
 338
 339   // Normal model.
 340   model.set_version(10);
 341   SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
 342                         net::URLRequestStatus::SUCCESS);
 343   EXPECT_CALL(service, EndFetchModel(
 344       ClientSideDetectionService::MODEL_SUCCESS))
 345       .WillOnce(QuitCurrentMessageLoop());
 346   service.StartFetchModel();
 347   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 348   Mock::VerifyAndClearExpectations(&service);
 349
 350   // Model version number is decreasing.  Set the model version number of the
 351   // model that is currently loaded in the service object to 11.
 352   service.model_.reset(new ClientSideModel(model));
 353   service.model_->set_version(11);
 354   SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
 355                         net::URLRequestStatus::SUCCESS);
 356   EXPECT_CALL(service, EndFetchModel(
 357       ClientSideDetectionService::MODEL_INVALID_VERSION_NUMBER))
 358       .WillOnce(QuitCurrentMessageLoop());
 359   service.StartFetchModel();
 360   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 361   Mock::VerifyAndClearExpectations(&service);
 362
 363   // Model version hasn't changed since the last reload.
 364   service.model_->set_version(10);
 365   SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
 366                         net::URLRequestStatus::SUCCESS);
 367   EXPECT_CALL(service, EndFetchModel(
 368       ClientSideDetectionService::MODEL_NOT_CHANGED))
 369       .WillOnce(QuitCurrentMessageLoop());
 370   service.StartFetchModel();
 371   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 372   Mock::VerifyAndClearExpectations(&service);
 373 }
 374
 375 TEST_F(ClientSideDetectionServiceTest, ServiceObjectDeletedBeforeCallbackDone) {
 376   SetModelFetchResponse("bogus model", net::HTTP_OK,
 377                         net::URLRequestStatus::SUCCESS);
 378   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 379   csd_service_->SetEnabledAndRefreshState(true);
 380   EXPECT_TRUE(csd_service_.get() != NULL);
 381   // We delete the client-side detection service class even though the callbacks
 382   // haven't run yet.
 383   csd_service_.reset();
 384   // Waiting for the callbacks to run should not crash even if the service
 385   // object is gone.
 386   msg_loop_.RunUntilIdle();
 387 }
 388
 389 TEST_F(ClientSideDetectionServiceTest, SendClientReportPhishingRequest) {
 390   SetModelFetchResponse("bogus model", net::HTTP_OK,
 391                         net::URLRequestStatus::SUCCESS);
 392   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 393   csd_service_->SetEnabledAndRefreshState(true);
 394
 395   GURL url("http://a.com/");
 396   float score = 0.4f;  // Some random client score.
 397
 398   base::Time before = base::Time::Now();
 399
 400   // Invalid response body from the server.
 401   SetClientReportPhishingResponse("invalid proto response", net::HTTP_OK,
 402                                   net::URLRequestStatus::SUCCESS);
 403   EXPECT_FALSE(SendClientReportPhishingRequest(url, score));
 404
 405   // Normal behavior.
 406   ClientPhishingResponse response;
 407   response.set_phishy(true);
 408   SetClientReportPhishingResponse(response.SerializeAsString(), net::HTTP_OK,
 409                                   net::URLRequestStatus::SUCCESS);
 410   EXPECT_TRUE(SendClientReportPhishingRequest(url, score));
 411
 412   // This request will fail
 413   GURL second_url("http://b.com/");
 414   response.set_phishy(false);
 415   SetClientReportPhishingResponse(response.SerializeAsString(),
 416                                   net::HTTP_INTERNAL_SERVER_ERROR,
 417                                   net::URLRequestStatus::FAILED);
 418   EXPECT_FALSE(SendClientReportPhishingRequest(second_url, score));
 419
 420   base::Time after = base::Time::Now();
 421
 422   // Check that we have recorded all 3 requests within the correct time range.
 423   std::queue<base::Time>& report_times = GetPhishingReportTimes();
 424   EXPECT_EQ(3U, report_times.size());
 425   while (!report_times.empty()) {
 426     base::Time time = report_times.back();
 427     report_times.pop();
 428     EXPECT_LE(before, time);
 429     EXPECT_GE(after, time);
 430   }
 431
 432   // Only the first url should be in the cache.
 433   bool is_phishing;
 434   EXPECT_TRUE(csd_service_->IsInCache(url));
 435   EXPECT_TRUE(csd_service_->GetValidCachedResult(url, &is_phishing));
 436   EXPECT_TRUE(is_phishing);
 437   EXPECT_FALSE(csd_service_->IsInCache(second_url));
 438 }
 439
 440 TEST_F(ClientSideDetectionServiceTest, SendClientReportMalwareRequest) {
 441   SetModelFetchResponse("bogus model", net::HTTP_OK,
 442                         net::URLRequestStatus::SUCCESS);
 443   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 444   csd_service_->SetEnabledAndRefreshState(true);
 445   GURL url("http://a.com/");
 446
 447   base::Time before = base::Time::Now();
 448   // Invalid response body from the server.
 449   SetClientReportMalwareResponse("invalid proto response", net::HTTP_OK,
 450                                  net::URLRequestStatus::SUCCESS);
 451   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 452
 453   // Missing bad_url.
 454   ClientMalwareResponse response;
 455   response.set_blacklist(true);
 456   SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK,
 457                                  net::URLRequestStatus::SUCCESS);
 458   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 459
 460   // Normal behavior.
 461   response.set_blacklist(true);
 462   response.set_bad_url("http://response-bad.com/");
 463   SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK,
 464                                  net::URLRequestStatus::SUCCESS);
 465   EXPECT_TRUE(SendClientReportMalwareRequest(url));
 466   CheckConfirmedMalwareUrl(GURL("http://response-bad.com/"));
 467
 468   // This request will fail
 469   response.set_blacklist(false);
 470   SetClientReportMalwareResponse(response.SerializeAsString(),
 471                                  net::HTTP_INTERNAL_SERVER_ERROR,
 472                                  net::URLRequestStatus::FAILED);
 473   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 474
 475   // Server blacklist decision is false, and response is successful
 476   response.set_blacklist(false);
 477   SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK,
 478                                  net::URLRequestStatus::SUCCESS);
 479   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 480
 481   // Check that we have recorded all 5 requests within the correct time range.
 482   base::Time after = base::Time::Now();
 483   std::queue<base::Time>& report_times = GetMalwareReportTimes();
 484   EXPECT_EQ(5U, report_times.size());
 485
 486   // Check that the malware report limit was reached.
 487   EXPECT_TRUE(csd_service_->OverMalwareReportLimit());
 488
 489   report_times = GetMalwareReportTimes();
 490   EXPECT_EQ(5U, report_times.size());
 491   while (!report_times.empty()) {
 492     base::Time time = report_times.back();
 493     report_times.pop();
 494     EXPECT_LE(before, time);
 495     EXPECT_GE(after, time);
 496   }
 497 }
 498
 499 TEST_F(ClientSideDetectionServiceTest, GetNumReportTest) {
 500   SetModelFetchResponse("bogus model", net::HTTP_OK,
 501                         net::URLRequestStatus::SUCCESS);
 502   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 503
 504   std::queue<base::Time>& report_times = GetPhishingReportTimes();
 505   base::Time now = base::Time::Now();
 506   base::TimeDelta twenty_five_hours = base::TimeDelta::FromHours(25);
 507   report_times.push(now - twenty_five_hours);
 508   report_times.push(now - twenty_five_hours);
 509   report_times.push(now);
 510   report_times.push(now);
 511
 512   EXPECT_EQ(2, GetNumReports(&report_times));
 513 }
 514
 515 TEST_F(ClientSideDetectionServiceTest, CacheTest) {
 516   SetModelFetchResponse("bogus model", net::HTTP_OK,
 517                         net::URLRequestStatus::SUCCESS);
 518   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 519
 520   TestCache();
 521 }
 522
 523 TEST_F(ClientSideDetectionServiceTest, IsPrivateIPAddress) {
 524   SetModelFetchResponse("bogus model", net::HTTP_OK,
 525                         net::URLRequestStatus::SUCCESS);
 526   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 527
 528   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("10.1.2.3"));
 529   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("127.0.0.1"));
 530   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("172.24.3.4"));
 531   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("192.168.1.1"));
 532   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("fc00::"));
 533   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("fec0::"));
 534   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("fec0:1:2::3"));
 535   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("::1"));
 536
 537   EXPECT_FALSE(csd_service_->IsPrivateIPAddress("1.2.3.4"));
 538   EXPECT_FALSE(csd_service_->IsPrivateIPAddress("200.1.1.1"));
 539   EXPECT_FALSE(csd_service_->IsPrivateIPAddress("2001:0db8:ac10:fe01::"));
 540
 541   // If the address can't be parsed, the default is true.
 542   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("blah"));
 543 }
 544
 545 TEST_F(ClientSideDetectionServiceTest, SetBadSubnets) {
 546   ClientSideModel model;
 547   ClientSideDetectionService::BadSubnetMap bad_subnets;
 548   ClientSideDetectionService::SetBadSubnets(model, &bad_subnets);
 549   EXPECT_EQ(0U, bad_subnets.size());
 550
 551   // Bad subnets are skipped.
 552   ClientSideModel::IPSubnet* subnet = model.add_bad_subnet();
 553   subnet->set_prefix(std::string(crypto::kSHA256Length, '.'));
 554   subnet->set_size(130);  // Invalid size.
 555
 556   subnet = model.add_bad_subnet();
 557   subnet->set_prefix(std::string(crypto::kSHA256Length, '.'));
 558   subnet->set_size(-1);  // Invalid size.
 559
 560   subnet = model.add_bad_subnet();
 561   subnet->set_prefix(std::string(16, '.'));  // Invalid len.
 562   subnet->set_size(64);
 563
 564   ClientSideDetectionService::SetBadSubnets(model, &bad_subnets);
 565   EXPECT_EQ(0U, bad_subnets.size());
 566
 567   subnet = model.add_bad_subnet();
 568   subnet->set_prefix(std::string(crypto::kSHA256Length, '.'));
 569   subnet->set_size(64);
 570
 571   subnet = model.add_bad_subnet();
 572   subnet->set_prefix(std::string(crypto::kSHA256Length, ','));
 573   subnet->set_size(64);
 574
 575   subnet = model.add_bad_subnet();
 576   subnet->set_prefix(std::string(crypto::kSHA256Length, '.'));
 577   subnet->set_size(128);
 578
 579   subnet = model.add_bad_subnet();
 580   subnet->set_prefix(std::string(crypto::kSHA256Length, '.'));
 581   subnet->set_size(100);
 582
 583   ClientSideDetectionService::SetBadSubnets(model, &bad_subnets);
 584   EXPECT_EQ(3U, bad_subnets.size());
 585   ClientSideDetectionService::BadSubnetMap::const_iterator it;
 586   std::string mask = std::string(8, '\xFF') + std::string(8, '\x00');
 587   EXPECT_TRUE(bad_subnets.count(mask));
 588   EXPECT_TRUE(bad_subnets[mask].count(std::string(crypto::kSHA256Length, '.')));
 589   EXPECT_TRUE(bad_subnets[mask].count(std::string(crypto::kSHA256Length, ',')));
 590
 591   mask = std::string(16, '\xFF');
 592   EXPECT_TRUE(bad_subnets.count(mask));
 593   EXPECT_TRUE(bad_subnets[mask].count(std::string(crypto::kSHA256Length, '.')));
 594
 595   mask = std::string(12, '\xFF') + "\xF0" + std::string(3, '\x00');
 596   EXPECT_TRUE(bad_subnets.count(mask));
 597   EXPECT_TRUE(bad_subnets[mask].count(std::string(crypto::kSHA256Length, '.')));
 598 }
 599
 600 TEST_F(ClientSideDetectionServiceTest, ModelHasValidHashIds) {
 601   ClientSideModel model;
 602   EXPECT_TRUE(ClientSideDetectionService::ModelHasValidHashIds(model));
 603   model.add_hashes("bla");
 604   EXPECT_TRUE(ClientSideDetectionService::ModelHasValidHashIds(model));
 605   model.add_page_term(0);
 606   EXPECT_TRUE(ClientSideDetectionService::ModelHasValidHashIds(model));
 607
 608   model.add_page_term(-1);
 609   EXPECT_FALSE(ClientSideDetectionService::ModelHasValidHashIds(model));
 610   model.set_page_term(1, 1);
 611   EXPECT_FALSE(ClientSideDetectionService::ModelHasValidHashIds(model));
 612   model.set_page_term(1, 0);
 613   EXPECT_TRUE(ClientSideDetectionService::ModelHasValidHashIds(model));
 614
 615   // Test bad rules.
 616   model.add_hashes("blu");
 617   ClientSideModel::Rule* rule = model.add_rule();
 618   rule->add_feature(0);
 619   rule->add_feature(1);
 620   rule->set_weight(0.1f);
 621   EXPECT_TRUE(ClientSideDetectionService::ModelHasValidHashIds(model));
 622
 623   rule = model.add_rule();
 624   rule->add_feature(0);
 625   rule->add_feature(1);
 626   rule->add_feature(-1);
 627   rule->set_weight(0.2f);
 628   EXPECT_FALSE(ClientSideDetectionService::ModelHasValidHashIds(model));
 629
 630   rule->set_feature(2, 2);
 631   EXPECT_FALSE(ClientSideDetectionService::ModelHasValidHashIds(model));
 632
 633   rule->set_feature(2, 1);
 634   EXPECT_TRUE(ClientSideDetectionService::ModelHasValidHashIds(model));
 635 }
 636
 637 TEST_F(ClientSideDetectionServiceTest, SetEnabledAndRefreshState) {
 638   // Check that the model isn't downloaded until the service is enabled.
 639   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 640   EXPECT_FALSE(csd_service_->enabled());
 641   EXPECT_TRUE(csd_service_->model_fetcher_.get() == NULL);
 642
 643   // Use a MockClientSideDetectionService for the rest of the test, to avoid
 644   // the scheduling delay.
 645   MockClientSideDetectionService* service =
 646       new StrictMock<MockClientSideDetectionService>();
 647   csd_service_.reset(service);
 648   EXPECT_FALSE(csd_service_->enabled());
 649   EXPECT_TRUE(csd_service_->model_fetcher_.get() == NULL);
 650   // No calls expected yet.
 651   Mock::VerifyAndClearExpectations(service);
 652
 653   ClientSideModel model;
 654   model.set_version(10);
 655   model.set_max_words_per_term(4);
 656   SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
 657                         net::URLRequestStatus::SUCCESS);
 658   EXPECT_CALL(*service, ScheduleFetchModel(_))
 659       .WillOnce(Invoke(service, &MockClientSideDetectionService::Schedule));
 660   EXPECT_CALL(*service, EndFetchModel(
 661       ClientSideDetectionService::MODEL_SUCCESS))
 662       .WillOnce(QuitCurrentMessageLoop());
 663   csd_service_->SetEnabledAndRefreshState(true);
 664   EXPECT_TRUE(csd_service_->model_fetcher_.get() != NULL);
 665   msg_loop_.Run();  // EndFetchModel will quit the message loop.
 666   Mock::VerifyAndClearExpectations(service);
 667
 668   // Check that enabling again doesn't request the model.
 669   csd_service_->SetEnabledAndRefreshState(true);
 670   // No calls expected.
 671   Mock::VerifyAndClearExpectations(service);
 672
 673   // Check that disabling the service cancels pending requests.
 674   EXPECT_CALL(*service, ScheduleFetchModel(_))
 675       .WillOnce(Invoke(service, &MockClientSideDetectionService::Schedule));
 676   csd_service_->SetEnabledAndRefreshState(false);
 677   csd_service_->SetEnabledAndRefreshState(true);
 678   Mock::VerifyAndClearExpectations(service);
 679   EXPECT_TRUE(csd_service_->model_fetcher_.get() != NULL);
 680   csd_service_->SetEnabledAndRefreshState(false);
 681   EXPECT_TRUE(csd_service_->model_fetcher_.get() == NULL);
 682   msg_loop_.RunUntilIdle();
 683   // No calls expected.
 684   Mock::VerifyAndClearExpectations(service);
 685
 686   // Requests always return false when the service is disabled.
 687   ClientPhishingResponse response;
 688   response.set_phishy(true);
 689   SetClientReportPhishingResponse(response.SerializeAsString(), net::HTTP_OK,
 690                                   net::URLRequestStatus::SUCCESS);
 691   EXPECT_FALSE(SendClientReportPhishingRequest(GURL("http://a.com/"), 0.4f));
 692
 693   // Pending requests also return false if the service is disabled before they
 694   // report back.
 695   EXPECT_CALL(*service, ScheduleFetchModel(_))
 696       .WillOnce(Invoke(service, &MockClientSideDetectionService::Schedule));
 697   EXPECT_CALL(*service, EndFetchModel(
 698       ClientSideDetectionService::MODEL_NOT_CHANGED))
 699       .WillOnce(Invoke(service, &MockClientSideDetectionService::Disable));
 700   csd_service_->SetEnabledAndRefreshState(true);
 701   EXPECT_FALSE(SendClientReportPhishingRequest(GURL("http://a.com/"), 0.4f));
 702   Mock::VerifyAndClearExpectations(service);
 703 }
 704 }  // namespace safe_browsing