Implement support for checking bad IPs aka MatchMalwareIP

components/safe_browsing_db/v4_protocol_manager_util.h

 // Copyright 2016 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.
 
 #ifndef COMPONENTS_SAFE_BROWSING_DB_V4_PROTOCOL_MANAGER_UTIL_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_PROTOCOL_MANAGER_UTIL_H_
 
 // A class that implements the stateless methods used by the GetHashUpdate and
 // GetFullHash stubby calls made by Chrome using the SafeBrowsing V4 protocol.
 
 #include <ostream>
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/hash.h"
 #include "base/strings/string_piece.h"
 #include "components/safe_browsing_db/safebrowsing.pb.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace net {
 class HttpRequestHeaders;
+class IPAddress;
 }  // namespace net
 
 namespace safe_browsing {
 
 // The size of the hash prefix, in bytes. It should be between 4 to 32 (full
 // hash).
 typedef size_t PrefixSize;
 
 // The minimum expected size (in bytes) of a hash-prefix.
 const PrefixSize kMinHashPrefixLength = 4;
@@ skipping 96 matching lines @@
   PlatformType platform_type_;
   ThreatEntryType threat_entry_type_;
   ThreatType threat_type_;
 
   ListIdentifier();
 };
 
 std::ostream& operator<<(std::ostream& os, const ListIdentifier& id);
 
 PlatformType GetCurrentPlatformType();
+const ListIdentifier GetAnyIpMalwareId();
 const ListIdentifier GetChromeUrlApiId();
 const ListIdentifier GetChromeUrlClientIncidentId();
 const ListIdentifier GetChromeUrlMalwareId();
 const ListIdentifier GetUrlMalwareId();
 const ListIdentifier GetUrlMalBinId();
 const ListIdentifier GetUrlSocEngId();
 const ListIdentifier GetUrlUwsId();
 
 // Represents the state of each store.
 typedef base::hash_map<ListIdentifier, std::string> StoreStateMap;
@@ skipping 116 matching lines @@
 
   static bool FullHashToSmallestHashPrefix(const FullHash& full_hash,
                                            HashPrefix* hash_prefix);
 
   static bool FullHashMatchesHashPrefix(const FullHash& full_hash,
                                         const HashPrefix& hash_prefix);
 
   static void SetClientInfoFromConfig(ClientInfo* client_info,
                                       const V4ProtocolConfig& config);
 
+  static bool GetIPV6AddressFromString(const std::string& ip_address,
+                                       net::IPAddress* address);
+
+  // Converts a IPV4 or IPV6 address in |ip_address| to the SHA1 hash of the
+  // corresponding packed IPV6 address in |hashed_encoded_ip|, and adds an
+  // extra byte containing the value 128 at the end. This is done to match the
+  // server implementation for calculating the hash prefix of an IP address.
+  static bool IPAddressToEncodedIPV6Hash(const std::string& ip_address,
+                                         FullHash* hashed_encoded_ip);
+
  private:
   V4ProtocolManagerUtil(){};
   FRIEND_TEST_ALL_PREFIXES(V4ProtocolManagerUtilTest, TestBackOffLogic);
   FRIEND_TEST_ALL_PREFIXES(V4ProtocolManagerUtilTest,
                            TestGetRequestUrlAndUpdateHeaders);
   FRIEND_TEST_ALL_PREFIXES(V4ProtocolManagerUtilTest, UrlParsing);
   FRIEND_TEST_ALL_PREFIXES(V4ProtocolManagerUtilTest, CanonicalizeUrl);
 
   // Composes a URL using |prefix|, |method| (e.g.: encodedFullHashes).
   // |request_base64|, |client_id|, |version| and |key_param|. |prefix|
@@ skipping 49 matching lines @@
 
 template <>
 struct hash<safe_browsing::ListIdentifier> {
   std::size_t operator()(const safe_browsing::ListIdentifier& id) const {
     return id.hash();
   }
 };
 }
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_PROTOCOL_MANAGER_UTIL_H_