Adds a function for encoding a Merkle tree leaf in TLS wire format.

net/cert/ct_serialization_unittest.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 "net/cert/ct_serialization.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
+#include "net/cert/merkle_tree_leaf.h"
 #include "net/cert/signed_certificate_timestamp.h"
 #include "net/cert/signed_tree_head.h"
 #include "net/cert/x509_certificate.h"
 #include "net/log/net_log.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"
 
+using ::testing::ElementsAreArray;
+
 namespace net {
 
 class CtSerializationTest : public ::testing::Test {
  public:
   void SetUp() override {
     test_digitally_signed_ = ct::GetTestDigitallySigned();
   }
 
  protected:
   std::string test_digitally_signed_;
@@ skipping 41 matching lines @@
 
   std::string encoded;
 
   ASSERT_TRUE(ct::EncodeDigitallySigned(digitally_signed, &encoded));
   EXPECT_EQ(test_digitally_signed_, encoded);
 }
 
 
 TEST_F(CtSerializationTest, EncodesLogEntryForX509Cert) {
   ct::LogEntry entry;
-  GetX509CertLogEntry(&entry);
+  ct::GetX509CertLogEntry(&entry);
 
   std::string encoded;
   ASSERT_TRUE(ct::EncodeLogEntry(entry, &encoded));
   EXPECT_EQ((718U + 5U), encoded.size());
   // First two bytes are log entry type. Next, length:
   // Length is 718 which is 512 + 206, which is 0x2ce
   std::string expected_prefix("\0\0\0\x2\xCE", 5);
   // Note we use std::string comparison rather than ASSERT_STREQ due
   // to null characters in the buffer.
   EXPECT_EQ(expected_prefix, encoded.substr(0, 5));
 }
 
+TEST_F(CtSerializationTest, EncodesLogEntryForPrecert) {
+  ct::LogEntry entry;
+  ct::GetPrecertLogEntry(&entry);
+
+  std::string encoded;
+  ASSERT_TRUE(ct::EncodeLogEntry(entry, &encoded));
+  EXPECT_EQ(604u, encoded.size());
+  // First two bytes are the log entry type.
+  EXPECT_EQ(std::string("\x00\x01", 2), encoded.substr(0, 2));
+  // Next comes the 32-byte issuer key hash
+  EXPECT_THAT(encoded.substr(2, 32),
+              ElementsAreArray(entry.issuer_key_hash.data));
+  // Then the length of the TBS cert (604 bytes = 0x237)
+  EXPECT_EQ(std::string("\x00\x02\x37", 3), encoded.substr(34, 3));
+  // Then the TBS cert itself
+  EXPECT_EQ(entry.tbs_certificate, encoded.substr(37));
+}
+
 TEST_F(CtSerializationTest, EncodesV1SCTSignedData) {
   base::Time timestamp = base::Time::UnixEpoch() +
       base::TimeDelta::FromMilliseconds(1348589665525);
   std::string dummy_entry("abc");
   std::string empty_extensions;
   // For now, no known failure cases.
   std::string encoded;
   ASSERT_TRUE(ct::EncodeV1SCTSignedData(
       timestamp,
       dummy_entry,
@@ skipping 52 matching lines @@
 
   ASSERT_FALSE(
       ct::DecodeSignedCertificateTimestamp(&invalid_version_sct, &sct));
 
   // Valid version, invalid length (missing data)
   base::StringPiece invalid_length_sct("\x0\xa\xb\xc", 4);
   ASSERT_FALSE(
       ct::DecodeSignedCertificateTimestamp(&invalid_length_sct, &sct));
 }
 
+TEST_F(CtSerializationTest, EncodesMerkleTreeLeafForX509Cert) {
+  ct::MerkleTreeLeaf tree_leaf;
+  ct::GetX509CertTreeLeaf(&tree_leaf);
+
+  std::string encoded;
+  ASSERT_TRUE(ct::EncodeTreeLeaf(tree_leaf, &encoded));
+  EXPECT_EQ(741u, encoded.size()) << "Merkle tree leaf encoded incorrectly";
+  EXPECT_EQ(std::string("\x00", 1), encoded.substr(0, 1)) <<
+      "Version encoded incorrectly";
+  EXPECT_EQ(std::string("\x00", 1), encoded.substr(1, 1)) <<
+      "Merkle tree leaf type encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x00\x01\x45\x3c\x5f\xb8\x35", 8),
+            encoded.substr(2, 8)) <<
+      "Timestamp encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x00", 2), encoded.substr(10, 2)) <<
+      "Log entry type encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x02\xce", 3), encoded.substr(12, 3)) <<
+      "Certificate length encoded incorrectly";
+  EXPECT_EQ(tree_leaf.log_entry.leaf_certificate, encoded.substr(15, 718)) <<
+      "Certificate encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x06", 2), encoded.substr(733, 2)) <<
+      "CT extensions length encoded incorrectly";
+  EXPECT_EQ(tree_leaf.extensions, encoded.substr(735, 6)) <<
+      "CT extensions encoded incorrectly";
+}
+
+TEST_F(CtSerializationTest, EncodesMerkleTreeLeafForPrecert) {
+  ct::MerkleTreeLeaf tree_leaf;
+  ct::GetPrecertTreeLeaf(&tree_leaf);
+
+  std::string encoded;
+  ASSERT_TRUE(ct::EncodeTreeLeaf(tree_leaf, &encoded));
+  EXPECT_EQ(622u, encoded.size()) << "Merkle tree leaf encoded incorrectly";
+  EXPECT_EQ(std::string("\x00", 1), encoded.substr(0, 1)) <<
+      "Version encoded incorrectly";
+  EXPECT_EQ(std::string("\x00", 1), encoded.substr(1, 1)) <<
+      "Merkle tree leaf type encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x00\x01\x45\x3c\x5f\xb8\x35", 8),
+            encoded.substr(2, 8)) <<
+      "Timestamp encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x01", 2), encoded.substr(10, 2)) <<
+      "Log entry type encoded incorrectly";
+  EXPECT_THAT(encoded.substr(12, 32),
+              ElementsAreArray(tree_leaf.log_entry.issuer_key_hash.data)) <<
+      "Issuer key hash encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x02\x37", 3), encoded.substr(44, 3)) <<
+      "TBS certificate length encoded incorrectly";
+  EXPECT_EQ(tree_leaf.log_entry.tbs_certificate, encoded.substr(47, 567)) <<
+      "TBS certificate encoded incorrectly";
+  EXPECT_EQ(std::string("\x00\x06", 2), encoded.substr(614, 2)) <<
+      "CT extensions length encoded incorrectly";
+  EXPECT_EQ(tree_leaf.extensions, encoded.substr(616, 6)) <<
+      "CT extensions encoded incorrectly";
+}
+
 TEST_F(CtSerializationTest, EncodesValidSignedTreeHead) {
   ct::SignedTreeHead signed_tree_head;
   ASSERT_TRUE(GetSampleSignedTreeHead(&signed_tree_head));
 
   std::string encoded;
   ct::EncodeTreeHeadSignature(signed_tree_head, &encoded);
   // Expected size is 50 bytes:
   // Byte 0 is version, byte 1 is signature type
   // Bytes 2-9 are timestamp
   // Bytes 10-17 are tree size
   // Bytes 18-49 are sha256 root hash
   ASSERT_EQ(50u, encoded.length());
   std::string expected_buffer(
       "\x0\x1\x0\x0\x1\x45\x3c\x5f\xb8\x35\x0\x0\x0\x0\x0\x0\x0\x15", 18);
   expected_buffer.append(ct::GetSampleSTHSHA256RootHash());
   ASSERT_EQ(expected_buffer, encoded);
 }
 
 }  // namespace net