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

net/cert/ct_serialization.h

 // 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.
 
 #ifndef NET_CERT_CT_SERIALIZATION_H_
 #define NET_CERT_CT_SERIALIZATION_H_
 
 #include <string>
 #include <vector>
 
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
+#include "net/cert/merkle_tree_leaf.h"

[Eran Messeri, 2016/05/05 15:59:33]

Nit: Can you get away with forward-declaring MerkleTreeLeaf? I would expect so,
given you only refer to it by const &.
You could add a TODO here to forward-declare everything possible.

[Rob Percival, 2016/05/05 17:31:43]

I can; I only didn't because nothing else was. I've created a new change that
forward-declares everything rather than adding a TODO:
https://codereview.chromium.org/1953773002.

 #include "net/cert/signed_certificate_timestamp.h"
 #include "net/cert/signed_tree_head.h"
 
 namespace net {
 
 // Utility functions for encoding/decoding structures used by Certificate
 // Transparency to/from the TLS wire format encoding.
 namespace ct {
 
 // If |input.signature_data| is less than kMaxSignatureLength, encodes the
 // |input| to |output| and returns true. Otherwise, returns false.
 NET_EXPORT_PRIVATE bool EncodeDigitallySigned(const DigitallySigned& input,
                                               std::string* output);
 
 // Reads and decodes a DigitallySigned object from |input|.
 // The bytes read from |input| are discarded (i.e. |input|'s prefix removed)
 // Returns true and fills |output| if all fields can be read, false otherwise.
 NET_EXPORT_PRIVATE bool DecodeDigitallySigned(base::StringPiece* input,
                                               DigitallySigned* output);
 
 // Encodes the |input| LogEntry to |output|. Returns true if the entry size
 // does not exceed allowed size in RFC6962, false otherwise.
 NET_EXPORT_PRIVATE bool EncodeLogEntry(const LogEntry& input,
                                        std::string* output);
 
+// Encodes the Merkle tree |leaf| into |output|.
+// These bytes can be hashed for use with inclusion proof fetching.
+// Note that the log ID is not serialized.
+NET_EXPORT bool EncodeTreeLeaf(const MerkleTreeLeaf& leaf, std::string* output);
+
 // Encodes the data signed by a Signed Certificate Timestamp (SCT) into
 // |output|. The signature included in the SCT is then verified over these
 // bytes.
 // |timestamp| timestamp from the SCT.
 // |serialized_log_entry| the log entry signed by the SCT.
 // |extensions| CT extensions.
 // Returns true if the extensions' length does not exceed
 // kMaxExtensionsLength, false otherwise.
 NET_EXPORT_PRIVATE bool EncodeV1SCTSignedData(
     const base::Time& timestamp,
@@ skipping 26 matching lines @@
     scoped_refptr<ct::SignedCertificateTimestamp>* output);
 
 // Writes an SCTList into |output|, containing a single |sct|.
 NET_EXPORT_PRIVATE bool EncodeSCTListForTesting(const base::StringPiece& sct,
                                                 std::string* output);
 }  // namespace ct
 
 }  // namespace net
 
 #endif  // NET_CERT_CT_SERIALIZATION_H_