Adds function for generating MerkleTreeLeaf hash.

net/cert/merkle_tree_leaf_unittest.cc

Index: net/cert/merkle_tree_leaf_unittest.cc
diff --git a/net/cert/merkle_tree_leaf_unittest.cc b/net/cert/merkle_tree_leaf_unittest.cc
index ab59237a199a3bed983b1d76483605a92da9de91..890645d335a3c6b319ec6d785d1bb349a64885f5 100644
--- a/net/cert/merkle_tree_leaf_unittest.cc
+++ b/net/cert/merkle_tree_leaf_unittest.cc
@@ -4,12 +4,16 @@
 
 #include "net/cert/merkle_tree_leaf.h"
 
+#include <string.h>
+
 #include <string>
 
+#include "base/strings/string_number_conversions.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/x509_certificate.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/ct_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -18,6 +22,24 @@ namespace ct {
 
 namespace {
 
+MATCHER_P(HexEq, hexStr, "") {
+  std::vector<uint8_t> bytes;
+
+  if (!base::HexStringToBytes(hexStr, &bytes)) {
+    *result_listener << "expected value was not a valid hex string";
+    return false;
+  }
+
+  if (bytes.size() != arg.size()) {
+    *result_listener << "expected and actual are different lengths";
+    return false;
+  }
+
+  // Print hex string (easier to read than default GTest representation)
+  *result_listener << "a.k.a. 0x" << base::HexEncode(arg.data(), arg.size());
+  return memcmp(arg.data(), bytes.data(), bytes.size()) == 0;

[eroman, 2016/05/06 23:51:22]

technically this is incorrect in the case where the input is empty (since
memcmp() is undefined when called with NULL pointers)

[Rob Percival, 2016/05/09 12:36:05]

Fixed. Surprisingly, that is only mentioned in the C++ spec, and not
specifically with regard to memcmp. All of the other documentation I could find
didn't mention that and, in fact, claimed that if the 3rd argument is 0, memcmp
was guaranteed to return 0. I suspect the latter is reality, and the former is
just unfortunate wording on the part of the spec, but I've fixed this
nonetheless.

[eroman, 2016/05/09 16:44:02]

Yeah, the C++ spec defers to the C spec for definition of memcmp.

And the the C spec implies that the pointers to memcmp/memcpy/memmove must be
non-NULL in 7.24.1:

"""Where an argument declared as size_t n specifies the length of the array for
a function, n can have the value zero on a call to that function. Unless
explicitly stated otherwise in the description of a particular function in this
subclause, pointer arguments on such a call shall still have valid values, as
described in 7.1.4."""

While this does seem like a spec bug to me (and completely idiotic behavior),
compilers *do* unfortunately exploit this undefined behavior :(

See for instance the "Null pointer checks may be optimized away more
aggressively" section in the GCC 4.9 release notes:
https://gcc.gnu.org/gcc-4.9/porting_to.html

This isn't just a theoretical problem; it impacted OpenSSL.

+}
+
 class MerkleTreeLeafTest : public ::testing::Test {
  public:
   void SetUp() override {
@@ -77,6 +99,26 @@ TEST_F(MerkleTreeLeafTest, DoesNotCreateForEmbeddedSCTButNotPrecert) {
   ASSERT_FALSE(GetMerkleTreeLeaf(test_cert_.get(), precert_sct_.get(), &leaf));
 }
 
+TEST_F(MerkleTreeLeafTest, HashForX509Cert) {
+  MerkleTreeLeaf leaf;
+  ct::GetX509CertTreeLeaf(&leaf);
+
+  std::string hash;
+  ASSERT_TRUE(Hash(leaf, &hash));
+  EXPECT_THAT(hash, HexEq("d306c83ef45ac97bba7a0d99331f23433e5fa97cf3a08ed90b24"

[eroman, 2016/05/06 23:51:22]

Where does this data come from?
Are there officially sanctioned test vectors you can use?

Given that I think the implementation has a bug, would be good to understand why
this works and whether it should.

[Rob Percival, 2016/05/09 12:36:05]

I independently generated this, by taking the serialized tree leaf produced in
the CtSerialization unit tests, writing to to a file using std::fstream
(attempting to prepend a zero byte in the process, but again using "\x00", which
got ignored as an empty string) and then passing it through sha256sum. I've
updated the expected hash values to the correct hashes now (I've added the zero
byte to the files by hand). 

There are tests for this sort of hashing in
https://github.com/google/certificate-transparency/blob/master/python/ct/cryp...
that I could borrow test data from, but no officially sanctioned test vectors
that I'm aware of.

+                          "2f7aec99f2ad"));
+}
+
+TEST_F(MerkleTreeLeafTest, HashForPrecert) {
+  MerkleTreeLeaf leaf;
+  ct::GetPrecertTreeLeaf(&leaf);
+
+  std::string hash;
+  ASSERT_TRUE(Hash(leaf, &hash));
+  EXPECT_THAT(hash, HexEq("d6f71fef189695a815b98d02d5b66f624323303172f75ff62f62"
+                          "44c01cde7cd3"));
+}
+
 }  // namespace
 
 }  // namespace ct