AU: Sign delta payloads

delta_performer_unittest.cc

 // Copyright (c) 2009 The Chromium OS 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 <sys/mount.h>
 #include <inttypes.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include <google/protobuf/repeated_field.h>
 #include <gtest/gtest.h>
 
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "update_engine/delta_diff_generator.h"
 #include "update_engine/delta_performer.h"
 #include "update_engine/graph_types.h"
+#include "update_engine/payload_signer.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/update_metadata.pb.h"
 #include "update_engine/utils.h"
 
 namespace chromeos_update_engine {
 
 using std::min;
 using std::string;
 using std::vector;
 
+extern const char* kUnittestPrivateKeyPath;
+
 class DeltaPerformerTest : public ::testing::Test { };
 
 TEST(DeltaPerformerTest, ExtentsToByteStringTest) {
   uint64_t test[] = {1, 1, 4, 2, kSparseHole, 1, 0, 1};
   COMPILE_ASSERT(arraysize(test) % 2 == 0, array_size_uneven);
   const uint64_t block_size = 4096;
   const uint64_t file_length = 5 * block_size - 13;
 
   google::protobuf::RepeatedPtrField<Extent> extents;
   for (size_t i = 0; i < arraysize(test); i += 2) {
@@ skipping 119 matching lines @@
   ScopedPathUnlinker old_kernel_unlinker(old_kernel);
 
   string new_kernel;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/new_kernel.XXXXXX", &new_kernel, NULL));
   ScopedPathUnlinker new_kernel_unlinker(new_kernel);
 
   vector<char> old_kernel_data(4096);  // Something small for a test
   vector<char> new_kernel_data(old_kernel_data.size());
   FillWithData(&old_kernel_data);
   FillWithData(&new_kernel_data);
-  
+
   // change the new kernel data
   const char* new_data_string = "This is new data.";
   strcpy(&new_kernel_data[0], new_data_string);
 
   // Write kernels to disk
   EXPECT_TRUE(utils::WriteFile(
       old_kernel.c_str(), &old_kernel_data[0], old_kernel_data.size()));
   EXPECT_TRUE(utils::WriteFile(
       new_kernel.c_str(), &new_kernel_data[0], new_kernel_data.size()));
 
   string delta_path;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/delta.XXXXXX", &delta_path, NULL));
+  LOG(INFO) << "delta path: " << delta_path;
   ScopedPathUnlinker delta_path_unlinker(delta_path);
   {
     string a_mnt, b_mnt;
     ScopedLoopMounter a_mounter(a_img, &a_mnt, MS_RDONLY);
     ScopedLoopMounter b_mounter(b_img, &b_mnt, MS_RDONLY);
 
-    EXPECT_TRUE(DeltaDiffGenerator::GenerateDeltaUpdateFile(a_mnt,
-                                                            a_img,
-                                                            b_mnt,
-                                                            b_img,
-                                                            old_kernel,
-                                                            new_kernel,
-                                                            delta_path));
+    EXPECT_TRUE(
+        DeltaDiffGenerator::GenerateDeltaUpdateFile(a_mnt,
+                                                    a_img,
+                                                    b_mnt,
+                                                    b_img,
+                                                    old_kernel,
+                                                    new_kernel,
+                                                    delta_path,
+                                                    kUnittestPrivateKeyPath));
   }
 
   // Read delta into memory.
   vector<char> delta;
   EXPECT_TRUE(utils::ReadFile(delta_path, &delta));
 
+  // Check that the null signature blob exists
+  {
+    LOG(INFO) << "delta size: " << delta.size();
+    DeltaArchiveManifest manifest;
+    const int kManifestSizeOffset = 12;
+    const int kManifestOffset = 20;
+    uint64_t manifest_size = 0;
+    memcpy(&manifest_size, &delta[kManifestSizeOffset], sizeof(manifest_size));
+    manifest_size = be64toh(manifest_size);
+    LOG(INFO) << "manifest size: " << manifest_size;
+    EXPECT_TRUE(manifest.ParseFromArray(&delta[kManifestOffset],
+                                        manifest_size));
+    EXPECT_TRUE(manifest.has_signatures_offset());
+
+    Signatures sigs_message;
+    EXPECT_TRUE(sigs_message.ParseFromArray(
+        &delta[kManifestOffset + manifest_size + manifest.signatures_offset()],
+        manifest.signatures_size()));
+    EXPECT_EQ(1, sigs_message.signatures_size());
+    const Signatures_Signature& signature = sigs_message.signatures(0);
+    EXPECT_EQ(1, signature.version());
+
+    uint64_t expected_sig_data_length = 0;
+    EXPECT_TRUE(PayloadSigner::SignatureBlobLength(kUnittestPrivateKeyPath,
+                                                   &expected_sig_data_length));
+    EXPECT_EQ(expected_sig_data_length, manifest.signatures_size());
+    EXPECT_FALSE(signature.data().empty());
+  }
+
   // Update the A image in place.
   DeltaPerformer performer;
 
   EXPECT_EQ(0, performer.Open(a_img.c_str(), 0, 0));
   EXPECT_TRUE(performer.OpenKernel(old_kernel.c_str()));
 
   // Write at some number of bytes per operation. Arbitrarily chose 5.
   const size_t kBytesPerWrite = 5;
   for (size_t i = 0; i < delta.size(); i += kBytesPerWrite) {
     size_t count = min(delta.size() - i, kBytesPerWrite);
     EXPECT_EQ(count, performer.Write(&delta[i], count));
   }
 
   // Wrapper around close. Returns 0 on success or -errno on error.
   EXPECT_EQ(0, performer.Close());
 
   CompareFilesByBlock(old_kernel, new_kernel);
-  
+
   vector<char> updated_kernel_partition;
   EXPECT_TRUE(utils::ReadFile(old_kernel, &updated_kernel_partition));
   EXPECT_EQ(0, strncmp(&updated_kernel_partition[0], new_data_string,
                        strlen(new_data_string)));
 }
 
 }  // namespace chromeos_update_engine