Serialisation code for Certificate Transparency data

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 <limits>
 
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string_util.h"
+#include "net/cert/merkle_consistency_proof.h"
 
 namespace net {
 
 namespace ct {
 
 namespace {
 
 // Note: length is always specified in bytes.
 // Signed Certificate Timestamp (SCT) Version length
 const size_t kVersionLength = 1;
@@ skipping 11 matching lines @@
 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 Consistency Proof
+const size_t kSha256HashLength = 32;
+const size_t kConsistencyPathLengthBytes = 8;
+
+// Length of the version field in a TransItem struct
+const size_t kTransItemVersionLength = 1;
+
+// Length of the type field in a TransItem{V1,V2} struct
+const size_t kTransTypeLength = 1;
+
 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 252 matching lines @@
             output);
   WriteUint(kSignatureTypeLength, SIGNATURE_TYPE_CERTIFICATE_TIMESTAMP,
             output);
   WriteTimeSinceEpoch(timestamp, output);
   // NOTE: serialized_log_entry must already be serialized and contain the
   // length as the prefix.
   WriteEncodedBytes(serialized_log_entry, output);
   return WriteVariableBytes(kExtensionsLengthBytes, extensions, output);
 }
 
+// TODO(robpercival): This could probably be named better, since the one thing
+// this doesn't encode is the signature. Perhaps just EncodeTreeHead, or
+// EncodeTreeHeadForSignature?
 void EncodeTreeHeadSignature(const SignedTreeHead& signed_tree_head,
                              std::string* output) {
   WriteUint(kVersionLength, signed_tree_head.version, output);
   WriteUint(kSignatureTypeLength, TREE_HASH, output);
   WriteTimeSinceEpoch(signed_tree_head.timestamp, output);
   WriteUint(kTreeSizeLength, signed_tree_head.tree_size, output);
   WriteEncodedBytes(
       base::StringPiece(signed_tree_head.sha256_root_hash, kSthRootHashLength),
       output);
 }
@@ skipping 45 matching lines @@
   log_id.CopyToString(&result->log_id);
   extensions.CopyToString(&result->extensions);
   result->timestamp =
       base::Time::UnixEpoch() +
       base::TimeDelta::FromMilliseconds(static_cast<int64_t>(timestamp));
 
   output->swap(result);
   return true;
 }
 
+bool EncodeSignedCertificateTimestamp(const SignedCertificateTimestamp& input,
+                                      std::string* output) {
+  WriteUint(kVersionLength, input.version, output);
+  DCHECK_EQ(kLogIdLength, WriteEncodedBytes(input.log_id, output));
+  WriteTimeSinceEpoch(input.timestamp, output);
+
+  if (!WriteVariableBytes(kExtensionsLengthBytes, input.extensions, output) ||
+      !EncodeDigitallySigned(input.signature, output)) {
+    return false;
+  }
+
+  return true;
+}
+
 bool EncodeSCTListForTesting(const base::StringPiece& sct,
                              std::string* output) {
   std::string encoded_sct;
   return WriteVariableBytes(kSerializedSCTLengthBytes, sct, &encoded_sct) &&
       WriteVariableBytes(kSCTListLengthBytes, encoded_sct, output);
 }
 
+bool DecodeSignedTreeHead(base::StringPiece* input, SignedTreeHead* output) {
+  base::StringPiece log_id;
+  base::StringPiece sha256_root_hash;
+  if (!ReadFixedBytes(kLogIdLength, input, &log_id) ||
+      !ReadTimeSinceEpoch(input, &output->timestamp) ||
+      !ReadUint(kTreeSizeLength, input, &output->tree_size) ||
+      !ReadFixedBytes(kSthRootHashLength, input, &sha256_root_hash)) {
+    return false;
+  }
+
+  log_id.CopyToString(&output->log_id);

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

A common pattern in this file is to decode to a temporary object and swap it
with |output| only if decoding succeeded.

+  log_id.copy(output->sha256_root_hash, kSthRootHashLength);
+  return true;
+}
+
+bool EncodeSignedTreeHead(const SignedTreeHead& input, std::string* output) {
+  DCHECK_EQ(kLogIdLength, WriteEncodedBytes(input.log_id, output));
+  WriteTimeSinceEpoch(input.timestamp, output);
+  WriteUint(kTreeSizeLength, input.tree_size, output);
+
+  base::StringPiece root_hash(input.sha256_root_hash, kSthRootHashLength);
+  WriteEncodedBytes(root_hash, output);
+
+  if (!EncodeDigitallySigned(input.signature, output)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool DecodeConsistencyProof(base::StringPiece* input,
+                            MerkleConsistencyProof* output) {
+  base::StringPiece log_id;
+  if (!ReadFixedBytes(kLogIdLength, input, &log_id)) {
+    return false;
+  }
+  log_id.CopyToString(&output->log_id);
+
+  if (!ReadUint(kTreeSizeLength, input, &output->first_tree_size)) {
+    return false;
+  }
+
+  if (!ReadUint(kTreeSizeLength, input, &output->second_tree_size)) {
+    return false;
+  }
+
+  base::StringPiece consistency_path;
+  if (!ReadVariableBytes(kConsistencyPathLengthBytes, input,
+                         &consistency_path)) {
+    return false;
+  }
+
+  for (size_t i = 0; i < consistency_path.size() / kSha256HashLength; ++i) {
+    base::StringPiece node_hash =
+        consistency_path.substr(kSha256HashLength * i, kSha256HashLength);
+
+    output->nodes.push_back(node_hash.as_string());
+  }
+
+  return true;
+}
+
+bool EncodeConsistencyProof(const MerkleConsistencyProof& input,
+                            std::string* output) {
+  WriteEncodedBytes(input.log_id, output);
+  WriteUint(kTreeSizeLength, input.first_tree_size, output);
+  WriteUint(kTreeSizeLength, input.second_tree_size, output);
+
+  std::string consistency_path = base::JoinString(input.nodes, "");
+  if (!WriteVariableBytes(kConsistencyPathLengthBytes, consistency_path,
+                          output)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool DecodeTransItem(base::StringPiece* input, TransItem* output) {
+  unsigned version;
+  if (!ReadUint(kTransItemVersionLength, input, &version)) {
+    return false;
+  }
+
+  switch (static_cast<TransItem::Version>(version)) {
+    case TransItem::Version::V1: {
+      scoped_ptr<TransItemV1> item(new TransItemV1());
+      if (!DecodeTransItem(input, item.get())) {
+        return false;
+      }
+      output->Set(std::move(item));
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool DecodeTransItem(base::StringPiece* input, TransItemV1* output) {
+  unsigned type;
+  if (!ReadUint(kTransTypeLength, input, &type)) {
+    return false;
+  }
+
+  switch (static_cast<TransType>(type)) {
+    case TransType::X509_SCT: {
+      scoped_refptr<SignedCertificateTimestamp> sct;
+      if (!DecodeSignedCertificateTimestamp(input, &sct)) {
+        return false;
+      }
+      output->SetX509Sct(sct);
+      return true;
+    }
+    case TransType::SIGNED_TREE_HEAD: {
+      SignedTreeHead sth;
+      if (!DecodeSignedTreeHead(input, &sth)) {
+        return false;
+      }
+      output->SetSignedTreeHead(sth);
+      return true;
+    }
+    case TransType::CONSISTENCY_PROOF: {
+      net::ct::MerkleConsistencyProof proof;
+      if (!DecodeConsistencyProof(input, &proof)) {
+        return false;
+      }
+      output->SetConsistencyProof(proof);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool EncodeTransItem(const TransItem& input, std::string* output) {
+  WriteUint(kTransItemVersionLength, static_cast<uint8_t>(input.version()),
+            output);
+
+  switch (input.version()) {
+    case TransItem::Version::V1:
+      return EncodeTransItem(input.v1(), output);
+  }
+
+  return false;
+}
+
+bool EncodeTransItem(const TransItemV1& input, std::string* output) {
+  WriteUint(kTransTypeLength, static_cast<uint8_t>(input.type()), output);
+
+  switch (input.type()) {
+    case TransType::X509_SCT:
+      return EncodeSignedCertificateTimestamp(*input.x509_sct(), output);
+    case TransType::SIGNED_TREE_HEAD:
+      return EncodeSignedTreeHead(input.signed_tree_head(), output);
+    case TransType::CONSISTENCY_PROOF:
+      return EncodeConsistencyProof(input.consistency_proof(), output);
+  }
+
+  return false;
+}
+
 }  // namespace ct
 
 }  // namespace net