Network traffic annotation added to install_signer.

chrome/browser/extensions/install_signer.cc

 // Copyright 2013 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 "chrome/browser/extensions/install_signer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_switches.h"
 #include "crypto/random.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "crypto/signature_verifier.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "rlz/features/features.h"
 #include "url/gurl.h"
 
 #if BUILDFLAG(ENABLE_RLZ)
 #include "rlz/lib/machine_id.h"
 #endif
@@ skipping 323 matching lines @@
 
   if (!context_getter_) {
     ReportErrorViaCallback();
     return;
   }
 
   base::Closure closure = base::Bind(&InstallSigner::ParseFetchResponse,
                                      base::Unretained(this));
 
   delegate_.reset(new FetcherDelegate(closure));
+  net::NetworkTrafficAnnotationTag traffic_annotation =
+      net::DefineNetworkTrafficAnnotation("extension_install_signer", R"(
+        semantics {
+          sender: "Extension Install Signer"
+          description: "Fetches the signatures for installed extensions."
+          trigger:
+            "Chrome detects an extension that requires installation "
+            "verification."
+          data:
+            "The ids of the extensions that need to be verified, as well as a "
+            "salted hash of the user's machine id."

[msramek, 2017/05/03 16:08:27]

If I'm reading the code correctly, we send RLZ if there is one (i.e. promotional
instance), and nothing otherwise?

How and when is the salt generated?

(To be clear, my questions are aimed at assessing the stability of this ID.)

[Devlin, 2017/05/08 15:19:02]

Yeah, the machine id comes from RLZ.  We don't send the raw machine id from RLZ,
but rather a hash of it + a salt.  The salt is generated right above this call
(line 361 of this patch set) through crypto::RandBytes(), which should be
strongly random.  By bundling the 25 (I think?) bit RLZ machine id with a 32-bit
random and hashing them in sha256, I think we have sufficient guarantees that
there's no way to determine the machine id, even a) by Google/the webstore or b)
between unrelated install signature calls (i.e., this id is intentionally
unstable).  This seems to only be included to verify the validity of the
response we receive.

[msramek, 2017/05/17 22:22:04]

Thanks, Devlin!

Ramin, then I would perhaps add that this is computed by the RLZ library,
included to verify the validity of the response, and emphasize that this is not
reversible (Devlin's points a) and b) ).

[Ramin Halavati, 2017/05/18 05:01:14]

Done.

+          destination: GOOGLE_OWNED_SERVICE
+        }
+        policy {
+          cookies_allowed: true
+          cookies_store: "user"
+          setting:
+            "This feature cannot be disabled, but it is only activated if "
+            "extensions are installed."
+          chrome_policy {
+            ExtensionInstallBlacklist {
+              policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+              ExtensionInstallBlacklist: '*'
+            }
+          }
+        })");
   url_fetcher_ = net::URLFetcher::Create(GetBackendUrl(), net::URLFetcher::POST,
-                                         delegate_.get());
+                                         delegate_.get(), traffic_annotation);
   url_fetcher_->SetRequestContext(context_getter_);
 
   // The request protocol is JSON of the form:
   // {
   //   "protocol_version": "1",
   //   "hash": "<base64-encoded hash value here>",
   //   "ids": [ "<id1>", "id2" ]
   // }
   base::DictionaryValue dictionary;
   dictionary.SetInteger(kProtocolVersionKey, 1);
@@ skipping 117 matching lines @@
     if (!verified)
       result.reset();
   }
 
   if (!callback_.is_null())
     callback_.Run(std::move(result));
 }
 
 
 }  // namespace extensions