network_time_tracker: add temporary time protocol.

components/client_update_protocol/ecdsa.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_CLIENT_UPDATE_PROTOCOL_ECDSA_H_
 #define COMPONENTS_CLIENT_UPDATE_PROTOCOL_ECDSA_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/strings/string_piece.h"
 
+// Testing peers. There's a better way to do this, but it probably makes sense
+// to wait til there are one or two more.
+namespace network_time {
+class NetworkTimeTrackerTest;
+}  // namespace network_time
+
 namespace client_update_protocol {
 
 // Client Update Protocol v2, or CUP-ECDSA, is used by Google Update (Omaha)
 // servers to ensure freshness and authenticity of server responses over HTTP,
 // without the overhead of HTTPS -- namely, no PKI, no guarantee of privacy, and
 // no request replay protection.
 //
 // CUP-ECDSA relies on a single signing operation using ECDSA with SHA-256,
 // instead of the original CUP which used HMAC-SHA1 with a random signing key
 // encrypted using RSA.
@@ skipping 18 matching lines @@
   // to the URL.
   //
   // This method will store internal state in this instance used by calls to
   // ValidateResponse(); if you need to have multiple pings in flight,
   // initialize a separate CUP-ECDSA instance for each one.
   void SignRequest(const base::StringPiece& request_body,
                    std::string* query_params);
 
   // Validates a response given to a ping previously signed with
   // SignRequest(). |response_body| contains the body of the response in
-  // UTF-8. |server_proof| contains the ECDSA signature and observed request
-  // hash, which is passed in the ETag HTTP header. Returns true if the response
-  // is valid and the observed request hash matches the sent hash.  This method
-  // uses internal state that is set by a prior SignRequest() call.
+  // UTF-8. |signature| contains the ECDSA signature and observed request
+  // hash. Returns true if the response is valid and the observed request hash
+  // matches the sent hash.  This method uses internal state that is set by a
+  // prior SignRequest() call.
   bool ValidateResponse(const base::StringPiece& response_body,
-                        const base::StringPiece& server_etag);
+                        const base::StringPiece& signature);
 
  private:
   friend class CupEcdsaTest;
+  friend class network_time::NetworkTimeTrackerTest;

[Ryan Sleevi, 2016/04/29 22:54:15]

FWIW, this feels like a layering violation (//components/client_update_protocol
sets below //components/network_time/, so CUP shouldn't know about network_time,
nor should network_time be reaching in to the implementation rather than the
interface).

The alternative way to do this would be something like OverrideKeyForTesting()
or something (as a public method), which our presubmit code would enforce is
only used in _unittest files. Whether that's strictly better is subjective - it
leaks more of the interface out, such that anyone can use it, but keeps the
dependencies better aligned. Just $.02

[mab, 2016/04/29 23:30:08]

I didn't know the |ForTesting| suffix was enforced.  That does change the
balance.  Done.

waffles, you OK with this?

[waffles, 2016/04/30 00:03:36]

I'm OK with it. I'll admit it seems a little bit weird to me.

 
   Ecdsa(int key_version, const base::StringPiece& public_key);
 
   // The server keeps multiple signing keys; a version must be sent so that
   // the correct signing key is used to sign the assembled message.
   const int pub_key_version_;
 
   // The ECDSA public key to use for verifying response signatures.
   const std::vector<uint8_t> public_key_;
 
   // The SHA-256 hash of the XML request.  This is modified on each call to
   // SignRequest(), and checked by ValidateResponse().
   std::vector<uint8_t> request_hash_;
 
   // The query string containing key version and nonce in UTF-8 form.  This is
   // modified on each call to SignRequest(), and checked by ValidateResponse().
   std::string request_query_cup2key_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Ecdsa);
 };
 
 }  // namespace client_update_protocol
 
 #endif  // COMPONENTS_CLIENT_UPDATE_PROTOCOL_ECDSA_H_