Certificate Transparency: Ensure timestamps over 32 bit are handled correctly.

net/cert/ct_log_response_parser.cc

 // Copyright 2014 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 "net/cert/ct_log_response_parser.h"
 
 #include "base/base64.h"
 #include "base/json/json_value_converter.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 127 matching lines @@
   if (!converter.Convert(json_signed_tree_head, &parsed_sth)) {
     DVLOG(1) << "Invalid Signed Tree Head JSON.";
     return false;
   }
 
   if (!IsJsonSTHStructurallyValid(parsed_sth))
     return false;
 
   signed_tree_head->version = SignedTreeHead::V1;
   signed_tree_head->tree_size = parsed_sth.tree_size;
-  signed_tree_head->timestamp =
-      base::Time::UnixEpoch() + base::TimeDelta::FromMilliseconds(
-                                    static_cast<int64_t>(parsed_sth.timestamp));
+  signed_tree_head->timestamp = base::Time::FromJsTime(parsed_sth.timestamp);

[Ryan Sleevi, 2016/03/02 19:03:22]

Are you sure this is correct? Js loses precision 

[davidben, 2016/03/02 19:11:46]

What do you mean? FromJsTime and JsonSignedTreeHead both take double. FromJsTime
uses TimeDelta::FromMillisecondsD which also takes a double.

[Ryan Sleevi, 2016/03/02 19:16:53]

I just meant that a 64-bit timestamp will be capped at 2^53-1 if round-tripping
through the double

[davidben, 2016/03/02 19:21:04]

Ah. (Well, it won't be capped but it'll lose precision beyond that point.)
That's true, but this isn't a 64-bit timestamp to begin with. JsonSignedTreeHead
is *already* a double. And JSONValueConverter doesn't have a
RegisterUint64Field, only RegisterIntField and RegisterDoubleField. This seems
fine.

[Eran Messeri, 2016/03/04 11:28:30]

What davidben said - I couldn't find a more accurate method and given that this
precision will carry us beyond the 26th century, I'm not too worried.

   signed_tree_head->signature = parsed_sth.signature;
   memcpy(signed_tree_head->sha256_root_hash,
          parsed_sth.sha256_root_hash.c_str(),
          kSthRootHashLength);
   return true;
 }
 
 bool FillConsistencyProof(const base::Value& json_consistency_proof,
                           std::vector<std::string>* consistency_proof) {
   JsonConsistencyProof parsed_proof;
@@ skipping 14 matching lines @@
   for (std::string* proof_node : parsed_proof.proof_nodes) {
     consistency_proof->push_back(*proof_node);
   }
 
   return true;
 }
 
 }  // namespace ct
 
 }  // namespace net