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 "chrome/browser/safe_browsing/client_side_detection_service.h" 6 7 #include "base/bind.h" 8 #include "base/command_line.h" 9 #include "base/logging.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/message_loop/message_loop.h" 12 #include "base/metrics/histogram.h" 13 #include "base/prefs/pref_service.h" 14 #include "base/stl_util.h" 15 #include "base/strings/string_util.h" 16 #include "base/time/time.h" 17 #include "chrome/browser/browser_process.h" 18 #include "chrome/browser/profiles/profile.h" 19 #include "chrome/common/chrome_switches.h" 20 #include "chrome/common/pref_names.h" 21 #include "chrome/common/safe_browsing/client_model.pb.h" 22 #include "chrome/common/safe_browsing/csd.pb.h" 23 #include "chrome/common/safe_browsing/safebrowsing_messages.h" 24 #include "content/public/browser/browser_thread.h" 25 #include "content/public/browser/notification_service.h" 26 #include "content/public/browser/notification_types.h" 27 #include "content/public/browser/render_process_host.h" 28 #include "crypto/sha2.h" 29 #include "google_apis/google_api_keys.h" 30 #include "net/base/escape.h" 31 #include "net/base/load_flags.h" 32 #include "net/http/http_response_headers.h" 33 #include "net/http/http_status_code.h" 34 #include "net/url_request/url_fetcher.h" 35 #include "net/url_request/url_request_context_getter.h" 36 #include "net/url_request/url_request_status.h" 37 #include "url/gurl.h" 38 39 using content::BrowserThread; 40 41 namespace safe_browsing { 42 43 namespace { 44 45 // malware report type for UMA histogram counting. 46 enum MalwareReportTypes { 47 REPORT_SENT, 48 REPORT_HIT_LIMIT, 49 REPORT_FAILED_SERIALIZATION, 50 51 // Always at the end 52 REPORT_RESULT_MAX 53 }; 54 55 void UpdateEnumUMAHistogram(MalwareReportTypes report_type) { 56 DCHECK(report_type >= 0 && report_type < REPORT_RESULT_MAX); 57 UMA_HISTOGRAM_ENUMERATION("SBClientMalware.SentReports", 58 report_type, REPORT_RESULT_MAX); 59 } 60 61 } // namespace 62 63 const size_t ClientSideDetectionService::kMaxModelSizeBytes = 90 * 1024; 64 const int ClientSideDetectionService::kMaxReportsPerInterval = 3; 65 // TODO(noelutz): once we know this mechanism works as intended we should fetch 66 // the model much more frequently. E.g., every 5 minutes or so. 67 const int ClientSideDetectionService::kClientModelFetchIntervalMs = 3600 * 1000; 68 const int ClientSideDetectionService::kInitialClientModelFetchDelayMs = 10000; 69 70 const int ClientSideDetectionService::kReportsIntervalDays = 1; 71 const int ClientSideDetectionService::kNegativeCacheIntervalDays = 1; 72 const int ClientSideDetectionService::kPositiveCacheIntervalMinutes = 30; 73 74 const char ClientSideDetectionService::kClientReportPhishingUrl[] = 75 "https://sb-ssl.google.com/safebrowsing/clientreport/phishing"; 76 const char ClientSideDetectionService::kClientReportMalwareUrl[] = 77 "https://sb-ssl.google.com/safebrowsing/clientreport/malware-check"; 78 const char ClientSideDetectionService::kClientModelUrl[] = 79 "https://ssl.gstatic.com/safebrowsing/csd/client_model_v4.pb"; 80 81 struct ClientSideDetectionService::ClientReportInfo { 82 ClientReportPhishingRequestCallback callback; 83 GURL phishing_url; 84 }; 85 86 ClientSideDetectionService::CacheState::CacheState(bool phish, base::Time time) 87 : is_phishing(phish), 88 timestamp(time) {} 89 90 ClientSideDetectionService::ClientSideDetectionService( 91 net::URLRequestContextGetter* request_context_getter) 92 : enabled_(false), 93 weak_factory_(this), 94 request_context_getter_(request_context_getter) { 95 registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED, 96 content::NotificationService::AllBrowserContextsAndSources()); 97 } 98 99 ClientSideDetectionService::~ClientSideDetectionService() { 100 weak_factory_.InvalidateWeakPtrs(); 101 STLDeleteContainerPairPointers(client_phishing_reports_.begin(), 102 client_phishing_reports_.end()); 103 client_phishing_reports_.clear(); 104 STLDeleteContainerPairPointers(client_malware_reports_.begin(), 105 client_malware_reports_.end()); 106 client_malware_reports_.clear(); 107 } 108 109 // static 110 ClientSideDetectionService* ClientSideDetectionService::Create( 111 net::URLRequestContextGetter* request_context_getter) { 112 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 113 scoped_ptr<ClientSideDetectionService> service( 114 new ClientSideDetectionService(request_context_getter)); 115 if (!service->InitializePrivateNetworks()) { 116 UMA_HISTOGRAM_COUNTS("SBClientPhishing.InitPrivateNetworksFailed", 1); 117 return NULL; 118 } 119 return service.release(); 120 } 121 122 void ClientSideDetectionService::SetEnabledAndRefreshState(bool enabled) { 123 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 124 SendModelToRenderers(); // always refresh the renderer state 125 if (enabled == enabled_) 126 return; 127 enabled_ = enabled; 128 if (enabled_) { 129 // Refresh the model when the service is enabled. This can happen when the 130 // preference is toggled, or early during startup if the preference is 131 // already enabled. In a lot of cases the model will be in the cache so it 132 // won't actually be fetched from the network. 133 // We delay the first model fetch to avoid slowing down browser startup. 134 ScheduleFetchModel(kInitialClientModelFetchDelayMs); 135 } else { 136 // Cancel pending requests. 137 model_fetcher_.reset(); 138 // Invoke pending callbacks with a false verdict. 139 for (std::map<const net::URLFetcher*, ClientReportInfo*>::iterator it = 140 client_phishing_reports_.begin(); 141 it != client_phishing_reports_.end(); ++it) { 142 ClientReportInfo* info = it->second; 143 if (!info->callback.is_null()) 144 info->callback.Run(info->phishing_url, false); 145 } 146 STLDeleteContainerPairPointers(client_phishing_reports_.begin(), 147 client_phishing_reports_.end()); 148 client_phishing_reports_.clear(); 149 for (std::map<const net::URLFetcher*, ClientReportInfo*>::iterator it = 150 client_malware_reports_.begin(); 151 it != client_malware_reports_.end(); ++it) { 152 ClientReportInfo* info = it->second; 153 if (!info->callback.is_null()) 154 info->callback.Run(info->phishing_url, false); 155 } 156 STLDeleteContainerPairPointers(client_malware_reports_.begin(), 157 client_malware_reports_.end()); 158 client_malware_reports_.clear(); 159 cache_.clear(); 160 } 161 } 162 163 void ClientSideDetectionService::SendClientReportPhishingRequest( 164 ClientPhishingRequest* verdict, 165 const ClientReportPhishingRequestCallback& callback) { 166 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 167 base::MessageLoop::current()->PostTask( 168 FROM_HERE, 169 base::Bind(&ClientSideDetectionService::StartClientReportPhishingRequest, 170 weak_factory_.GetWeakPtr(), verdict, callback)); 171 } 172 173 void ClientSideDetectionService::SendClientReportMalwareRequest( 174 ClientMalwareRequest* verdict, 175 const ClientReportMalwareRequestCallback& callback) { 176 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 177 base::MessageLoop::current()->PostTask( 178 FROM_HERE, 179 base::Bind(&ClientSideDetectionService::StartClientReportMalwareRequest, 180 weak_factory_.GetWeakPtr(), verdict, callback)); 181 } 182 183 bool ClientSideDetectionService::IsPrivateIPAddress( 184 const std::string& ip_address) const { 185 net::IPAddressNumber ip_number; 186 if (!net::ParseIPLiteralToNumber(ip_address, &ip_number)) { 187 VLOG(2) << "Unable to parse IP address: '" << ip_address << "'"; 188 // Err on the side of safety and assume this might be private. 189 return true; 190 } 191 192 for (std::vector<AddressRange>::const_iterator it = 193 private_networks_.begin(); 194 it != private_networks_.end(); ++it) { 195 if (net::IPNumberMatchesPrefix(ip_number, it->first, it->second)) { 196 return true; 197 } 198 } 199 return false; 200 } 201 202 bool ClientSideDetectionService::IsBadIpAddress( 203 const std::string& ip_address) const { 204 net::IPAddressNumber ip_number; 205 if (!net::ParseIPLiteralToNumber(ip_address, &ip_number)) { 206 VLOG(2) << "Unable to parse IP address: '" << ip_address << "'"; 207 return false; 208 } 209 if (ip_number.size() == net::kIPv4AddressSize) { 210 ip_number = net::ConvertIPv4NumberToIPv6Number(ip_number); 211 } 212 if (ip_number.size() != net::kIPv6AddressSize) { 213 VLOG(2) << "Unable to convert IPv4 address to IPv6: '" << ip_address << "'"; 214 return false; // better safe than sorry. 215 } 216 for (BadSubnetMap::const_iterator it = bad_subnets_.begin(); 217 it != bad_subnets_.end(); ++it) { 218 const std::string& mask = it->first; 219 DCHECK_EQ(mask.size(), ip_number.size()); 220 std::string subnet(net::kIPv6AddressSize, '.'); 221 for (size_t i = 0; i < net::kIPv6AddressSize; ++i) { 222 subnet[i] = ip_number[i] & mask[i]; 223 } 224 if (it->second.count(crypto::SHA256HashString(subnet)) > 0) { 225 return true; 226 } 227 } 228 return false; 229 } 230 231 void ClientSideDetectionService::OnURLFetchComplete( 232 const net::URLFetcher* source) { 233 std::string data; 234 source->GetResponseAsString(&data); 235 if (source == model_fetcher_.get()) { 236 HandleModelResponse( 237 source, source->GetURL(), source->GetStatus(), 238 source->GetResponseCode(), source->GetCookies(), data); 239 } else if (client_phishing_reports_.find(source) != 240 client_phishing_reports_.end()) { 241 HandlePhishingVerdict( 242 source, source->GetURL(), source->GetStatus(), 243 source->GetResponseCode(), source->GetCookies(), data); 244 } else if (client_malware_reports_.find(source) != 245 client_malware_reports_.end()) { 246 HandleMalwareVerdict( 247 source, source->GetURL(), source->GetStatus(), 248 source->GetResponseCode(), source->GetCookies(), data); 249 } else { 250 NOTREACHED(); 251 } 252 } 253 254 void ClientSideDetectionService::Observe( 255 int type, 256 const content::NotificationSource& source, 257 const content::NotificationDetails& details) { 258 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 259 DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_CREATED); 260 if (!model_.get()) { 261 // Model might not be ready or maybe there was an error. 262 return; 263 } 264 SendModelToProcess( 265 content::Source<content::RenderProcessHost>(source).ptr()); 266 } 267 268 void ClientSideDetectionService::SendModelToProcess( 269 content::RenderProcessHost* process) { 270 // The ClientSideDetectionService is enabled if _any_ active profile has 271 // SafeBrowsing turned on. Here we check the profile for each renderer 272 // process and only send the model to those that have SafeBrowsing enabled. 273 Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext()); 274 std::string model; 275 if (profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled)) { 276 VLOG(2) << "Sending phishing model to RenderProcessHost @" << process; 277 model = model_str_; 278 } else { 279 VLOG(2) << "Disabling client-side phishing detection for " 280 << "RenderProcessHost @" << process; 281 } 282 process->Send(new SafeBrowsingMsg_SetPhishingModel(model)); 283 } 284 285 void ClientSideDetectionService::SendModelToRenderers() { 286 for (content::RenderProcessHost::iterator i( 287 content::RenderProcessHost::AllHostsIterator()); 288 !i.IsAtEnd(); i.Advance()) { 289 SendModelToProcess(i.GetCurrentValue()); 290 } 291 } 292 293 void ClientSideDetectionService::ScheduleFetchModel(int64 delay_ms) { 294 if (CommandLine::ForCurrentProcess()->HasSwitch( 295 switches::kSbDisableAutoUpdate)) 296 return; 297 base::MessageLoop::current()->PostDelayedTask( 298 FROM_HERE, 299 base::Bind(&ClientSideDetectionService::StartFetchModel, 300 weak_factory_.GetWeakPtr()), 301 base::TimeDelta::FromMilliseconds(delay_ms)); 302 } 303 304 void ClientSideDetectionService::StartFetchModel() { 305 if (enabled_) { 306 // Start fetching the model either from the cache or possibly from the 307 // network if the model isn't in the cache. 308 model_fetcher_.reset(net::URLFetcher::Create( 309 0 /* ID used for testing */, GURL(kClientModelUrl), 310 net::URLFetcher::GET, this)); 311 model_fetcher_->SetRequestContext(request_context_getter_.get()); 312 model_fetcher_->Start(); 313 } 314 } 315 316 void ClientSideDetectionService::EndFetchModel(ClientModelStatus status) { 317 UMA_HISTOGRAM_ENUMERATION("SBClientPhishing.ClientModelStatus", 318 status, 319 MODEL_STATUS_MAX); 320 if (status == MODEL_SUCCESS) { 321 SetBadSubnets(*model_, &bad_subnets_); 322 SendModelToRenderers(); 323 } 324 int delay_ms = kClientModelFetchIntervalMs; 325 // If the most recently fetched model had a valid max-age and the model was 326 // valid we're scheduling the next model update for after the max-age expired. 327 if (model_max_age_.get() && 328 (status == MODEL_SUCCESS || status == MODEL_NOT_CHANGED)) { 329 // We're adding 60s of additional delay to make sure we're past 330 // the model's age. 331 *model_max_age_ += base::TimeDelta::FromMinutes(1); 332 delay_ms = model_max_age_->InMilliseconds(); 333 } 334 model_max_age_.reset(); 335 336 // Schedule the next model reload. 337 ScheduleFetchModel(delay_ms); 338 } 339 340 void ClientSideDetectionService::StartClientReportPhishingRequest( 341 ClientPhishingRequest* verdict, 342 const ClientReportPhishingRequestCallback& callback) { 343 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 344 scoped_ptr<ClientPhishingRequest> request(verdict); 345 346 if (!enabled_) { 347 if (!callback.is_null()) 348 callback.Run(GURL(request->url()), false); 349 return; 350 } 351 352 std::string request_data; 353 if (!request->SerializeToString(&request_data)) { 354 UMA_HISTOGRAM_COUNTS("SBClientPhishing.RequestNotSerialized", 1); 355 VLOG(1) << "Unable to serialize the CSD request. Proto file changed?"; 356 if (!callback.is_null()) 357 callback.Run(GURL(request->url()), false); 358 return; 359 } 360 361 net::URLFetcher* fetcher = net::URLFetcher::Create( 362 0 /* ID used for testing */, 363 GURL(GetClientReportUrl(kClientReportPhishingUrl)), 364 net::URLFetcher::POST, this); 365 366 // Remember which callback and URL correspond to the current fetcher object. 367 ClientReportInfo* info = new ClientReportInfo; 368 info->callback = callback; 369 info->phishing_url = GURL(request->url()); 370 client_phishing_reports_[fetcher] = info; 371 372 fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE); 373 fetcher->SetRequestContext(request_context_getter_.get()); 374 fetcher->SetUploadData("application/octet-stream", request_data); 375 fetcher->Start(); 376 377 // Record that we made a request 378 phishing_report_times_.push(base::Time::Now()); 379 } 380 381 void ClientSideDetectionService::StartClientReportMalwareRequest( 382 ClientMalwareRequest* verdict, 383 const ClientReportMalwareRequestCallback& callback) { 384 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 385 scoped_ptr<ClientMalwareRequest> request(verdict); 386 387 if (!enabled_) { 388 if (!callback.is_null()) 389 callback.Run(GURL(request->url()), false); 390 return; 391 } 392 393 if (OverMalwareReportLimit()) { 394 UpdateEnumUMAHistogram(REPORT_HIT_LIMIT); 395 DVLOG(1) << "Too many malware report requests sent recently." 396 << "Skip sending malware report for " << GURL(request->url()); 397 if (!callback.is_null()) 398 callback.Run(GURL(request->url()), false); 399 return; 400 } 401 402 std::string request_data; 403 if (!request->SerializeToString(&request_data)) { 404 UpdateEnumUMAHistogram(REPORT_FAILED_SERIALIZATION); 405 DVLOG(1) << "Unable to serialize the CSD request. Proto file changed?"; 406 if (!callback.is_null()) 407 callback.Run(GURL(request->url()), false); 408 return; 409 } 410 411 net::URLFetcher* fetcher = net::URLFetcher::Create( 412 0 /* ID used for testing */, 413 GURL(GetClientReportUrl(kClientReportMalwareUrl)), 414 net::URLFetcher::POST, this); 415 416 // Remember which callback and URL correspond to the current fetcher object. 417 // TODO: need to modify to malware specific code 418 ClientReportInfo* info = new ClientReportInfo; 419 info->callback = callback; 420 info->phishing_url = GURL(request->url()); 421 client_malware_reports_[fetcher] = info; 422 423 fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE); 424 fetcher->SetRequestContext(request_context_getter_.get()); 425 fetcher->SetUploadData("application/octet-stream", request_data); 426 fetcher->Start(); 427 428 UMA_HISTOGRAM_ENUMERATION("SBClientMalware.SentReports", 429 REPORT_SENT, REPORT_RESULT_MAX); 430 431 // Record that we made a malware request 432 malware_report_times_.push(base::Time::Now()); 433 } 434 435 void ClientSideDetectionService::HandleModelResponse( 436 const net::URLFetcher* source, 437 const GURL& url, 438 const net::URLRequestStatus& status, 439 int response_code, 440 const net::ResponseCookies& cookies, 441 const std::string& data) { 442 base::TimeDelta max_age; 443 if (status.is_success() && net::HTTP_OK == response_code && 444 source->GetResponseHeaders() && 445 source->GetResponseHeaders()->GetMaxAgeValue(&max_age)) { 446 model_max_age_.reset(new base::TimeDelta(max_age)); 447 } 448 scoped_ptr<ClientSideModel> model(new ClientSideModel()); 449 ClientModelStatus model_status; 450 if (!status.is_success() || net::HTTP_OK != response_code) { 451 model_status = MODEL_FETCH_FAILED; 452 } else if (data.empty()) { 453 model_status = MODEL_EMPTY; 454 } else if (data.size() > kMaxModelSizeBytes) { 455 model_status = MODEL_TOO_LARGE; 456 } else if (!model->ParseFromString(data)) { 457 model_status = MODEL_PARSE_ERROR; 458 } else if (!model->IsInitialized() || !model->has_version()) { 459 model_status = MODEL_MISSING_FIELDS; 460 } else if (!ModelHasValidHashIds(*model)) { 461 model_status = MODEL_BAD_HASH_IDS; 462 } else if (model->version() < 0 || 463 (model_.get() && model->version() < model_->version())) { 464 model_status = MODEL_INVALID_VERSION_NUMBER; 465 } else if (model_.get() && model->version() == model_->version()) { 466 model_status = MODEL_NOT_CHANGED; 467 } else { 468 // The model is valid => replace the existing model with the new one. 469 model_str_.assign(data); 470 model_.swap(model); 471 model_status = MODEL_SUCCESS; 472 } 473 EndFetchModel(model_status); 474 } 475 476 void ClientSideDetectionService::HandlePhishingVerdict( 477 const net::URLFetcher* source, 478 const GURL& url, 479 const net::URLRequestStatus& status, 480 int response_code, 481 const net::ResponseCookies& cookies, 482 const std::string& data) { 483 ClientPhishingResponse response; 484 scoped_ptr<ClientReportInfo> info(client_phishing_reports_[source]); 485 bool is_phishing = false; 486 if (status.is_success() && net::HTTP_OK == response_code && 487 response.ParseFromString(data)) { 488 // Cache response, possibly flushing an old one. 489 cache_[info->phishing_url] = 490 make_linked_ptr(new CacheState(response.phishy(), base::Time::Now())); 491 is_phishing = response.phishy(); 492 } else { 493 DLOG(ERROR) << "Unable to get the server verdict for URL: " 494 << info->phishing_url << " status: " << status.status() << " " 495 << "response_code:" << response_code; 496 } 497 if (!info->callback.is_null()) 498 info->callback.Run(info->phishing_url, is_phishing); 499 client_phishing_reports_.erase(source); 500 delete source; 501 } 502 503 void ClientSideDetectionService::HandleMalwareVerdict( 504 const net::URLFetcher* source, 505 const GURL& url, 506 const net::URLRequestStatus& status, 507 int response_code, 508 const net::ResponseCookies& cookies, 509 const std::string& data) { 510 ClientMalwareResponse response; 511 scoped_ptr<ClientReportInfo> info(client_malware_reports_[source]); 512 bool should_blacklist = false; 513 if (status.is_success() && net::HTTP_OK == response_code && 514 response.ParseFromString(data)) { 515 should_blacklist = response.blacklist(); 516 } else { 517 DLOG(ERROR) << "Unable to get the server verdict for URL: " 518 << info->phishing_url << " status: " << status.status() << " " 519 << "response_code:" << response_code; 520 } 521 if (!info->callback.is_null()) 522 info->callback.Run(info->phishing_url, should_blacklist); 523 client_malware_reports_.erase(source); 524 delete source; 525 } 526 527 bool ClientSideDetectionService::IsInCache(const GURL& url) { 528 UpdateCache(); 529 530 return cache_.find(url) != cache_.end(); 531 } 532 533 bool ClientSideDetectionService::GetValidCachedResult(const GURL& url, 534 bool* is_phishing) { 535 UpdateCache(); 536 537 PhishingCache::iterator it = cache_.find(url); 538 if (it == cache_.end()) { 539 return false; 540 } 541 542 // We still need to check if the result is valid. 543 const CacheState& cache_state = *it->second; 544 if (cache_state.is_phishing ? 545 cache_state.timestamp > base::Time::Now() - 546 base::TimeDelta::FromMinutes(kPositiveCacheIntervalMinutes) : 547 cache_state.timestamp > base::Time::Now() - 548 base::TimeDelta::FromDays(kNegativeCacheIntervalDays)) { 549 *is_phishing = cache_state.is_phishing; 550 return true; 551 } 552 return false; 553 } 554 555 void ClientSideDetectionService::UpdateCache() { 556 // Since we limit the number of requests but allow pass-through for cache 557 // refreshes, we don't want to remove elements from the cache if they 558 // could be used for this purpose even if we will not use the entry to 559 // satisfy the request from the cache. 560 base::TimeDelta positive_cache_interval = 561 std::max(base::TimeDelta::FromMinutes(kPositiveCacheIntervalMinutes), 562 base::TimeDelta::FromDays(kReportsIntervalDays)); 563 base::TimeDelta negative_cache_interval = 564 std::max(base::TimeDelta::FromDays(kNegativeCacheIntervalDays), 565 base::TimeDelta::FromDays(kReportsIntervalDays)); 566 567 // Remove elements from the cache that will no longer be used. 568 for (PhishingCache::iterator it = cache_.begin(); it != cache_.end();) { 569 const CacheState& cache_state = *it->second; 570 if (cache_state.is_phishing ? 571 cache_state.timestamp > base::Time::Now() - positive_cache_interval : 572 cache_state.timestamp > base::Time::Now() - negative_cache_interval) { 573 ++it; 574 } else { 575 cache_.erase(it++); 576 } 577 } 578 } 579 580 bool ClientSideDetectionService::OverMalwareReportLimit() { 581 return GetMalwareNumReports() > kMaxReportsPerInterval; 582 } 583 584 bool ClientSideDetectionService::OverPhishingReportLimit() { 585 return GetPhishingNumReports() > kMaxReportsPerInterval; 586 } 587 588 int ClientSideDetectionService::GetMalwareNumReports() { 589 return GetNumReports(&malware_report_times_); 590 } 591 592 int ClientSideDetectionService::GetPhishingNumReports() { 593 return GetNumReports(&phishing_report_times_); 594 } 595 596 int ClientSideDetectionService::GetNumReports( 597 std::queue<base::Time>* report_times) { 598 base::Time cutoff = 599 base::Time::Now() - base::TimeDelta::FromDays(kReportsIntervalDays); 600 601 // Erase items older than cutoff because we will never care about them again. 602 while (!report_times->empty() && 603 report_times->front() < cutoff) { 604 report_times->pop(); 605 } 606 607 // Return the number of elements that are above the cutoff. 608 return report_times->size(); 609 } 610 611 bool ClientSideDetectionService::InitializePrivateNetworks() { 612 static const char* const kPrivateNetworks[] = { 613 "10.0.0.0/8", 614 "127.0.0.0/8", 615 "172.16.0.0/12", 616 "192.168.0.0/16", 617 // IPv6 address ranges 618 "fc00::/7", 619 "fec0::/10", 620 "::1/128", 621 }; 622 623 for (size_t i = 0; i < arraysize(kPrivateNetworks); ++i) { 624 net::IPAddressNumber ip_number; 625 size_t prefix_length; 626 if (net::ParseCIDRBlock(kPrivateNetworks[i], &ip_number, &prefix_length)) { 627 private_networks_.push_back(std::make_pair(ip_number, prefix_length)); 628 } else { 629 DLOG(FATAL) << "Unable to parse IP address range: " 630 << kPrivateNetworks[i]; 631 return false; 632 } 633 } 634 return true; 635 } 636 637 // static 638 void ClientSideDetectionService::SetBadSubnets(const ClientSideModel& model, 639 BadSubnetMap* bad_subnets) { 640 bad_subnets->clear(); 641 for (int i = 0; i < model.bad_subnet_size(); ++i) { 642 int size = model.bad_subnet(i).size(); 643 if (size < 0 || size > static_cast<int>(net::kIPv6AddressSize) * 8) { 644 DLOG(ERROR) << "Invalid bad subnet size: " << size; 645 continue; 646 } 647 if (model.bad_subnet(i).prefix().size() != crypto::kSHA256Length) { 648 DLOG(ERROR) << "Invalid bad subnet prefix length: " 649 << model.bad_subnet(i).prefix().size(); 650 continue; 651 } 652 // We precompute the mask for the given subnet size to speed up lookups. 653 // Basically we need to create a 16B long string which has the highest 654 // |size| bits sets to one. 655 std::string mask(net::kIPv6AddressSize, '\x00'); 656 mask.replace(0, size / 8, size / 8, '\xFF'); 657 if (size % 8) { 658 mask[size / 8] = 0xFF << (8 - (size % 8)); 659 } 660 (*bad_subnets)[mask].insert(model.bad_subnet(i).prefix()); 661 } 662 } 663 664 // static 665 bool ClientSideDetectionService::ModelHasValidHashIds( 666 const ClientSideModel& model) { 667 const int max_index = model.hashes_size() - 1; 668 for (int i = 0; i < model.rule_size(); ++i) { 669 for (int j = 0; j < model.rule(i).feature_size(); ++j) { 670 if (model.rule(i).feature(j) < 0 || 671 model.rule(i).feature(j) > max_index) { 672 return false; 673 } 674 } 675 } 676 for (int i = 0; i < model.page_term_size(); ++i) { 677 if (model.page_term(i) < 0 || model.page_term(i) > max_index) { 678 return false; 679 } 680 } 681 return true; 682 } 683 684 // static 685 std::string ClientSideDetectionService::GetClientReportUrl( 686 const std::string& report_url) { 687 std::string url = report_url; 688 std::string api_key = google_apis::GetAPIKey(); 689 if (!api_key.empty()) { 690 base::StringAppendF(&url, "?key=%s", 691 net::EscapeQueryParamValue(api_key, true).c_str()); 692 } 693 return url; 694 } 695 } // namespace safe_browsing 696
