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

net/cert/ct_serialization.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 <stdint.h>
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 
 namespace net {
 
 namespace ct {
 
 namespace {
 
 // Note: length is always specified in bytes.
-// Signed Certificate Timestamp (SCT) Version length
+// CT protocol version length
 const size_t kVersionLength = 1;
+const size_t kSha256HashLength = 32;

[Eran Messeri, 2016/05/04 10:29:23]

This is redundant, you can use the definition from
https://code.google.com/p/chromium/codesearch#chromium/src/crypto/sha2.h&q=cr...

[Rob Percival, 2016/05/05 15:45:31]

Done.

+
+// Common V1 struct members
+const size_t kTimestampLength = 8;
+const size_t kLogEntryTypeLength = 2;
+const size_t kAsn1CertificateLengthBytes = 3;
+const size_t kTbsCertificateLengthBytes = 3;
+const size_t kExtensionsLengthBytes = 2;
 
 // Members of a V1 SCT
-const size_t kLogIdLength = 32;
-const size_t kTimestampLength = 8;
-const size_t kExtensionsLengthBytes = 2;
+const size_t kLogIdLength = kSha256HashLength;
 const size_t kHashAlgorithmLength = 1;
 const size_t kSigAlgorithmLength = 1;
 const size_t kSignatureLengthBytes = 2;
 
 // Members of the digitally-signed struct of a V1 SCT
 const size_t kSignatureTypeLength = 1;
-const size_t kLogEntryTypeLength = 2;
-const size_t kAsn1CertificateLengthBytes = 3;
-const size_t kTbsCertificateLengthBytes = 3;
 
 const size_t kSCTListLengthBytes = 2;
 const size_t kSerializedSCTLengthBytes = 2;
 
 // Members of digitally-signed struct of a STH
 const size_t kTreeSizeLength = 8;
 
+// Members of a V1 MerkleTreeLeaf
+const size_t kMerkleLeafTypeLength = 1;
+const size_t kIssuerKeyHashLength = kSha256HashLength;
+
 enum SignatureType {
   SIGNATURE_TYPE_CERTIFICATE_TIMESTAMP = 0,
   TREE_HASH = 1,
 };
 
 // Reads a TLS-encoded variable length unsigned integer from |in|.
 // The integer is expected to be in big-endian order, which is used by TLS.
 // The bytes read from |in| are discarded (i.e. |in|'s prefix removed)
 // |length| indicates the size (in bytes) of the integer. On success, returns
 // true and stores the result in |*out|.
@@ skipping 192 matching lines @@
 }
 
 // Writes a LogEntry of type PreCertificate to |output|.
 // |input| is the LogEntry containing the TBSCertificate and issuer key hash.
 // Returns true if the TBSCertificate component in the LogEntry does not
 // exceed kMaxTbsCertificateLength and so can be written to |output|.
 bool EncodePrecertLogEntry(const LogEntry& input, std::string* output) {
   WriteEncodedBytes(
       base::StringPiece(
           reinterpret_cast<const char*>(input.issuer_key_hash.data),
-          kLogIdLength),
+          kIssuerKeyHashLength),
       output);
   return WriteVariableBytes(kTbsCertificateLengthBytes,
                             input.tbs_certificate, output);
 }
 
 }  // namespace
 
 bool EncodeDigitallySigned(const DigitallySigned& input,
                            std::string* output) {
   WriteUint(kHashAlgorithmLength, input.hash_algorithm, output);
@@ skipping 60 matching lines @@
 
   return true;
 }
 
 static void WriteTimeSinceEpoch(const base::Time& timestamp,
                                 std::string* output) {
   base::TimeDelta time_since_epoch = timestamp - base::Time::UnixEpoch();
   WriteUint(kTimestampLength, time_since_epoch.InMilliseconds(), output);
 }
 
+bool EncodeTreeLeaf(const MerkleTreeLeaf& leaf, std::string* output) {
+  WriteUint(kVersionLength, MerkleTreeLeaf::VERSION_1, output);
+  WriteUint(kMerkleLeafTypeLength, MerkleTreeLeaf::TYPE_TIMESTAMPED_ENTRY,
+            output);
+  WriteTimeSinceEpoch(leaf.timestamp, output);
+  if (!EncodeLogEntry(leaf.log_entry, output))
+      return false;
+  if (!WriteVariableBytes(kExtensionsLengthBytes, leaf.extensions, output))
+      return false;
+
+  return true;
+}
+
 bool EncodeV1SCTSignedData(const base::Time& timestamp,
                            const std::string& serialized_log_entry,
                            const std::string& extensions,
                            std::string* output) {
   WriteUint(kVersionLength, SignedCertificateTimestamp::SCT_VERSION_1,
             output);
   WriteUint(kSignatureTypeLength, SIGNATURE_TYPE_CERTIFICATE_TIMESTAMP,
             output);
   WriteTimeSinceEpoch(timestamp, output);
   // NOTE: serialized_log_entry must already be serialized and contain the
@@ skipping 59 matching lines @@
 bool EncodeSCTListForTesting(const base::StringPiece& sct,
                              std::string* output) {
   std::string encoded_sct;
   return WriteVariableBytes(kSerializedSCTLengthBytes, sct, &encoded_sct) &&
          WriteVariableBytes(kSCTListLengthBytes, encoded_sct, output);
 }
 
 }  // namespace ct
 
 }  // namespace net