Serialisation code for Certificate Transparency data

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/ct_trans_item.h"
 #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 {
 
+struct MerkleConsistencyProof;
+struct TransItem;

[Eran Messeri, 2016/01/14 12:46:45]

Unnecessary as you're including ct_trans_item.h

+
 // 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);
@@ skipping 34 matching lines @@
 NET_EXPORT_PRIVATE bool DecodeSCTList(base::StringPiece* input,
                                       std::vector<base::StringPiece>* output);
 
 // Decodes a single SCT from |input| to |output|.
 // Returns true if all fields in the SCT could be read and decoded, false
 // otherwise.
 NET_EXPORT_PRIVATE bool DecodeSignedCertificateTimestamp(
     base::StringPiece* input,
     scoped_refptr<ct::SignedCertificateTimestamp>* output);
 
+NET_EXPORT_PRIVATE bool EncodeSignedCertificateTimestamp(
+    const SignedCertificateTimestamp& input,
+    std::string* output);
+
 // Writes an SCTList into |output|, containing a single |sct|.
 NET_EXPORT_PRIVATE bool EncodeSCTListForTesting(const base::StringPiece& sct,
                                                 std::string* output);
+
+NET_EXPORT_PRIVATE bool DecodeSignedTreeHead(base::StringPiece* input,

[Eran Messeri, 2016/01/14 12:46:45]

Comment that all of these are from RFC6962-bis, not RFC6962 (i.e. RFC6962 does
not need TLS encoding of these structures).

+                                             SignedTreeHead* output);
+
+NET_EXPORT_PRIVATE bool EncodeSignedTreeHead(const SignedTreeHead& sth,
+                                             std::string* output);
+
+NET_EXPORT_PRIVATE bool DecodeConsistencyProof(base::StringPiece* input,
+                                               MerkleConsistencyProof* output);
+
+NET_EXPORT_PRIVATE bool EncodeConsistencyProof(
+    const MerkleConsistencyProof& input,
+    std::string* output);
+
+// Decodes a CT item from |input| to |output|.
+// Any pointers in |output| are owned by the caller.
+// Returns true if all fields in the TransItem could be read and decoded, false
+// otherwise.
+NET_EXPORT bool DecodeTransItem(base::StringPiece* input, TransItem* output);
+
+NET_EXPORT_PRIVATE bool DecodeTransItem(base::StringPiece* input,
+                                        TransItemV1* output);
+
+// Encodes the TransItem |input| into |output|.
+// Returns true if all of the fields in the TransItem could be encoded and
+// written, false otherwise.
+NET_EXPORT bool EncodeTransItem(const TransItem& input, std::string* output);
+
+NET_EXPORT bool EncodeTransItem(const TransItemV1& input, std::string* output);
+
 }  // namespace ct
 
 }  // namespace net
 
 #endif  // NET_CERT_CT_SERIALIZATION_H_