Implement support for checking bad IPs aka MatchMalwareIP

components/safe_browsing_db/v4_protocol_manager_util.cc

 // 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.
 
 #include "components/safe_browsing_db/v4_protocol_manager_util.h"
 
 #include "base/base64.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
+#include "base/sha1.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "crypto/sha2.h"
 #include "net/base/escape.h"
+#include "net/base/ip_address.h"
 #include "net/http/http_request_headers.h"
 #include "url/url_util.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace safe_browsing {
 
 namespace {
 
@@ skipping 54 matching lines @@
 #else
 // This should ideally never compile but it is getting compiled on Android.
 // See: https://bugs.chromium.org/p/chromium/issues/detail?id=621647
 // TODO(vakh): Once that bug is fixed, this should be removed. If we leave
 // the platform_type empty, the server won't recognize the request and
 // return an error response which will pollute our UMA metrics.
 return LINUX_PLATFORM;
 #endif
 }
 
+const ListIdentifier GetAnyIpMalwareId() {
+  return ListIdentifier(ANY_PLATFORM, IP_RANGE, MALWARE_THREAT);
+}
+
 const ListIdentifier GetChromeUrlApiId() {
   return ListIdentifier(CHROME_PLATFORM, URL, API_ABUSE);
 }
 
 const ListIdentifier GetChromeUrlClientIncidentId() {
   return ListIdentifier(CHROME_PLATFORM, URL, CLIENT_INCIDENT);
 }
 
 const ListIdentifier GetChromeUrlMalwareId() {
   return ListIdentifier(CHROME_PLATFORM, URL, MALWARE_THREAT);
@@ skipping 423 matching lines @@
 
 // static
 void V4ProtocolManagerUtil::SetClientInfoFromConfig(
     ClientInfo* client_info,
     const V4ProtocolConfig& config) {
   DCHECK(client_info);
   client_info->set_client_id(config.client_name);
   client_info->set_client_version(config.version);
 }
 
+// static
+bool V4ProtocolManagerUtil::GetIPV6AddressFromString(
+    const std::string& ip_address,
+    net::IPAddress* address) {
+  DCHECK(address);
+  if (!address->AssignFromIPLiteral(ip_address))
+    return false;
+  if (address->IsIPv4())
+    *address = net::ConvertIPv4ToIPv4MappedIPv6(*address);
+  return address->IsIPv6();
+}
+
+// static
+bool V4ProtocolManagerUtil::IPAddressToEncodedIPV6Hash(
+    const std::string& ip_address,
+    FullHash* hashed_encoded_ip) {
+  net::IPAddress address;
+  if (!GetIPV6AddressFromString(ip_address, &address)) {
+    return false;
+  }
+  std::string packed_ip = net::IPAddressToPackedString(address);
+  if (packed_ip.empty()) {
+    return false;
+  }
+
+  const std::string hash = base::SHA1HashString(packed_ip);

[Nathan Parker, 2016/11/15 00:54:46]

Maybe DCHECK that the size is 20, since that's what the server assumes.

[vakh (use Gerrit instead), 2016/11/15 01:03:41]

Done.

+  hashed_encoded_ip->resize(hash.size() + 1);
+  hashed_encoded_ip->replace(0, hash.size(), hash);
+  (*hashed_encoded_ip)[hash.size()] = static_cast<unsigned char>(128);
+  return true;
+}
+
 }  // namespace safe_browsing