Serialisation code for Certificate Transparency data

net/test/ct_test_util.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/test/ct_test_util.h"
 
 #include <stdint.h>
 #include <string>
 #include <vector>
 
@@ skipping 187 matching lines @@
 
 std::string GetTestPublicKeyId() {
   return HexToBytes(kTestKeyId);
 }
 
 void GetX509CertSCT(scoped_refptr<SignedCertificateTimestamp>* sct_ref) {
   CHECK(sct_ref != NULL);
   *sct_ref = new SignedCertificateTimestamp();
   SignedCertificateTimestamp *const sct(sct_ref->get());
   sct->version = ct::SignedCertificateTimestamp::SCT_VERSION_1;
-  sct->log_id = HexToBytes(kTestKeyId);
+  sct->log_id = GetTestPublicKeyId();
   // Time the log issued a SCT for this certificate, which is
   // Fri Apr  5 10:04:16.089 2013
   sct->timestamp = base::Time::UnixEpoch() +
       base::TimeDelta::FromMilliseconds(INT64_C(1365181456089));
   sct->extensions.clear();
 
   sct->signature.hash_algorithm = ct::DigitallySigned::HASH_ALGO_SHA256;
   sct->signature.signature_algorithm = ct::DigitallySigned::SIG_ALGO_ECDSA;
   sct->signature.signature_data = HexToBytes(kTestSCTSignatureData);
 }
 
 void GetPrecertSCT(scoped_refptr<SignedCertificateTimestamp>* sct_ref) {
   CHECK(sct_ref != NULL);
   *sct_ref = new SignedCertificateTimestamp();
   SignedCertificateTimestamp *const sct(sct_ref->get());
   sct->version = ct::SignedCertificateTimestamp::SCT_VERSION_1;
-  sct->log_id = HexToBytes(kTestKeyId);
+  sct->log_id = GetTestPublicKeyId();
   // Time the log issued a SCT for this Precertificate, which is
   // Fri Apr  5 10:04:16.275 2013
   sct->timestamp = base::Time::UnixEpoch() +
     base::TimeDelta::FromMilliseconds(INT64_C(1365181456275));
   sct->extensions.clear();
 
   sct->signature.hash_algorithm = ct::DigitallySigned::HASH_ALGO_SHA256;
   sct->signature.signature_algorithm = ct::DigitallySigned::SIG_ALGO_ECDSA;
   sct->signature.signature_data = HexToBytes(kTestSCTPrecertSignatureData);
 }
@@ skipping 14 matching lines @@
   return HexToBytes(kFakeOCSPResponseCert);
 }
 
 std::string GetDerEncodedFakeOCSPResponseIssuerCert() {
   return HexToBytes(kFakeOCSPResponseIssuerCert);
 }
 
 // A sample, valid STH
 void GetSampleSignedTreeHead(SignedTreeHead* sth) {
   sth->version = SignedTreeHead::V1;
+  sth->log_id = GetTestPublicKeyId();
   sth->timestamp = base::Time::UnixEpoch() +
                    base::TimeDelta::FromMilliseconds(kSampleSTHTimestamp);
   sth->tree_size = kSampleSTHTreeSize;
   std::string sha256_root_hash = GetSampleSTHSHA256RootHash();
   memcpy(sth->sha256_root_hash, sha256_root_hash.c_str(), kSthRootHashLength);
 
   GetSampleSTHTreeHeadDecodedSignature(&(sth->signature));
 }
 
 std::string GetSampleSTHSHA256RootHash() {
   return HexToBytes(kSampleSTHSHA256RootHash);
 }
 
 std::string GetSampleSTHTreeHeadSignature() {
   return HexToBytes(kSampleSTHTreeHeadSignature);
 }
 
 void GetSampleSTHTreeHeadDecodedSignature(DigitallySigned* signature) {
   std::string tree_head_signature = HexToBytes(kSampleSTHTreeHeadSignature);
   base::StringPiece sp(tree_head_signature);
   CHECK(DecodeDigitallySigned(&sp, signature));
   CHECK(sp.empty());
 }
 
+std::string GetSampleSTH() {
+  const std::string log_id = ct::GetTestPublicKeyId();
+  const std::string timestamp("\x0\x0\x1\x45\x3c\x5f\xb8\x35", 8);

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

Why not use the encoding functions you've added to avoid manually encoding these
values?

+  const std::string tree_size("\x0\x0\x0\x0\x0\x0\x0\x15", 8);
+
+  std::string expected_output;
+  expected_output += log_id;
+  expected_output += timestamp;
+  expected_output += tree_size;
+  expected_output += ct::GetSampleSTHSHA256RootHash();
+  expected_output += ct::GetSampleSTHTreeHeadSignature();
+
+  return expected_output;
+}
+
 std::string GetSampleSTHAsJson() {
   return CreateSignedTreeHeadJsonString(kSampleSTHTreeSize, kSampleSTHTimestamp,
                                         GetSampleSTHSHA256RootHash(),
                                         GetSampleSTHTreeHeadSignature());
 }
 
 std::string CreateSignedTreeHeadJsonString(size_t tree_size,
                                            int64_t timestamp,
                                            std::string sha256_root_hash,
                                            std::string tree_head_signature) {
@@ skipping 31 matching lines @@
       consistency_proof_json += std::string(",");
   }
   consistency_proof_json += std::string("]}");
 
   return consistency_proof_json;
 }
 
 }  // namespace ct
 
 }  // namespace net