Home | History | Annotate | Download | only in safe_browsing 
      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 // Helper class which handles communication with the SafeBrowsing servers for
      6 // improved binary download protection.
      7 
      8 #ifndef CHROME_BROWSER_SAFE_BROWSING_DOWNLOAD_PROTECTION_SERVICE_H_
      9 #define CHROME_BROWSER_SAFE_BROWSING_DOWNLOAD_PROTECTION_SERVICE_H_
     10 
     11 #include <set>
     12 #include <string>
     13 #include <vector>
     14 
     15 #include "base/basictypes.h"
     16 #include "base/callback.h"
     17 #include "base/files/file_path.h"
     18 #include "base/gtest_prod_util.h"
     19 #include "base/memory/ref_counted.h"
     20 #include "chrome/browser/safe_browsing/database_manager.h"
     21 #include "chrome/browser/safe_browsing/ui_manager.h"
     22 #include "url/gurl.h"
     23 
     24 
     25 namespace content {
     26 class DownloadItem;
     27 class PageNavigator;
     28 }
     29 
     30 namespace net {
     31 class URLRequestContextGetter;
     32 class X509Certificate;
     33 }  // namespace net
     34 
     35 namespace safe_browsing {
     36 class DownloadFeedbackService;
     37 class BinaryFeatureExtractor;
     38 
     39 // This class provides an asynchronous API to check whether a particular
     40 // client download is malicious or not.
     41 class DownloadProtectionService {
     42  public:
     43   enum DownloadCheckResult {
     44     UNKNOWN,
     45     SAFE,
     46     DANGEROUS,
     47     UNCOMMON,
     48     DANGEROUS_HOST,
     49     POTENTIALLY_UNWANTED
     50   };
     51 
     52   // Callback type which is invoked once the download request is done.
     53   typedef base::Callback<void(DownloadCheckResult)> CheckDownloadCallback;
     54 
     55   // Creates a download service.  The service is initially disabled.  You need
     56   // to call SetEnabled() to start it.  |sb_service| owns this object; we
     57   // keep a reference to |request_context_getter|.
     58   DownloadProtectionService(
     59       SafeBrowsingService* sb_service,
     60       net::URLRequestContextGetter* request_context_getter);
     61 
     62   virtual ~DownloadProtectionService();
     63 
     64   // Checks whether the given client download is likely to be malicious or not.
     65   // The result is delivered asynchronously via the given callback.  This
     66   // method must be called on the UI thread, and the callback will also be
     67   // invoked on the UI thread.  This method must be called once the download
     68   // is finished and written to disk.
     69   virtual void CheckClientDownload(content::DownloadItem* item,
     70                                    const CheckDownloadCallback& callback);
     71 
     72   // Checks whether any of the URLs in the redirect chain of the
     73   // download match the SafeBrowsing bad binary URL list.  The result is
     74   // delivered asynchronously via the given callback.  This method must be
     75   // called on the UI thread, and the callback will also be invoked on the UI
     76   // thread.  Pre-condition: !info.download_url_chain.empty().
     77   virtual void CheckDownloadUrl(const content::DownloadItem& item,
     78                                 const CheckDownloadCallback& callback);
     79 
     80   // Returns true iff the download specified by |info| should be scanned by
     81   // CheckClientDownload() for malicious content.
     82   virtual bool IsSupportedDownload(const content::DownloadItem& item,
     83                                    const base::FilePath& target_path) const;
     84 
     85   // Display more information to the user regarding the download specified by
     86   // |info|. This method is invoked when the user requests more information
     87   // about a download that was marked as malicious.
     88   void ShowDetailsForDownload(const content::DownloadItem& item,
     89                               content::PageNavigator* navigator);
     90 
     91   // Enables or disables the service.  This is usually called by the
     92   // SafeBrowsingService, which tracks whether any profile uses these services
     93   // at all.  Disabling causes any pending and future requests to have their
     94   // callbacks called with "UNKNOWN" results.
     95   void SetEnabled(bool enabled);
     96 
     97   bool enabled() const {
     98     return enabled_;
     99   }
    100 
    101   // Returns the timeout that is used by CheckClientDownload().
    102   int64 download_request_timeout_ms() const {
    103     return download_request_timeout_ms_;
    104   }
    105 
    106   DownloadFeedbackService* feedback_service() {
    107     return feedback_service_.get();
    108   }
    109 
    110  protected:
    111   // Enum to keep track why a particular download verdict was chosen.
    112   // This is used to keep some stats around.
    113   enum DownloadCheckResultReason {
    114     REASON_INVALID_URL,
    115     REASON_SB_DISABLED,
    116     REASON_WHITELISTED_URL,
    117     REASON_WHITELISTED_REFERRER,
    118     REASON_INVALID_REQUEST_PROTO,
    119     REASON_SERVER_PING_FAILED,
    120     REASON_INVALID_RESPONSE_PROTO,
    121     REASON_NOT_BINARY_FILE,
    122     REASON_REQUEST_CANCELED,
    123     REASON_DOWNLOAD_DANGEROUS,
    124     REASON_DOWNLOAD_SAFE,
    125     REASON_EMPTY_URL_CHAIN,
    126     DEPRECATED_REASON_HTTPS_URL,
    127     REASON_PING_DISABLED,
    128     REASON_TRUSTED_EXECUTABLE,
    129     REASON_OS_NOT_SUPPORTED,
    130     REASON_DOWNLOAD_UNCOMMON,
    131     REASON_DOWNLOAD_NOT_SUPPORTED,
    132     REASON_INVALID_RESPONSE_VERDICT,
    133     REASON_ARCHIVE_WITHOUT_BINARIES,
    134     REASON_DOWNLOAD_DANGEROUS_HOST,
    135     REASON_DOWNLOAD_POTENTIALLY_UNWANTED,
    136     REASON_MAX  // Always add new values before this one.
    137   };
    138 
    139  private:
    140   class CheckClientDownloadRequest;  // Per-request state
    141   friend class DownloadProtectionServiceTest;
    142   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    143                            CheckClientDownloadWhitelistedUrl);
    144   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    145                            CheckClientDownloadValidateRequest);
    146   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    147                            CheckClientDownloadSuccess);
    148   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    149                            CheckClientDownloadHTTPS);
    150   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    151                            CheckClientDownloadZip);
    152   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    153                            CheckClientDownloadFetchFailed);
    154   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    155                            TestDownloadRequestTimeout);
    156   FRIEND_TEST_ALL_PREFIXES(DownloadProtectionServiceTest,
    157                            CheckClientCrxDownloadSuccess);
    158   static const char kDownloadRequestUrl[];
    159 
    160   // Cancels all requests in |download_requests_|, and empties it, releasing
    161   // the references to the requests.
    162   void CancelPendingRequests();
    163 
    164   // Called by a CheckClientDownloadRequest instance when it finishes, to
    165   // remove it from |download_requests_|.
    166   void RequestFinished(CheckClientDownloadRequest* request);
    167 
    168   // Given a certificate and its immediate issuer certificate, generates the
    169   // list of strings that need to be checked against the download whitelist to
    170   // determine whether the certificate is whitelisted.
    171   static void GetCertificateWhitelistStrings(
    172       const net::X509Certificate& certificate,
    173       const net::X509Certificate& issuer,
    174       std::vector<std::string>* whitelist_strings);
    175 
    176   // Returns the URL that will be used for download requests.
    177   static GURL GetDownloadRequestUrl();
    178 
    179   // These pointers may be NULL if SafeBrowsing is disabled.
    180   scoped_refptr<SafeBrowsingUIManager> ui_manager_;
    181   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
    182 
    183   // The context we use to issue network requests.
    184   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
    185 
    186   // Map of client download request to the corresponding callback that
    187   // has to be invoked when the request is done.  This map contains all
    188   // pending server requests.
    189   std::set<scoped_refptr<CheckClientDownloadRequest> > download_requests_;
    190 
    191   // Keeps track of the state of the service.
    192   bool enabled_;
    193 
    194   // BinaryFeatureExtractor object, may be overridden for testing.
    195   scoped_refptr<BinaryFeatureExtractor> binary_feature_extractor_;
    196 
    197   int64 download_request_timeout_ms_;
    198 
    199   scoped_ptr<DownloadFeedbackService> feedback_service_;
    200 
    201   DISALLOW_COPY_AND_ASSIGN(DownloadProtectionService);
    202 };
    203 }  // namespace safe_browsing
    204 
    205 #endif  // CHROME_BROWSER_SAFE_BROWSING_DOWNLOAD_PROTECTION_SERVICE_H_
    206