AU: Add support for signing of update payloads after they're generated.

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>
@@ skipping 74 matching lines @@
 bool WriteSparseFile(const string& path, off_t size) {
   int fd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0644);
   TEST_AND_RETURN_FALSE_ERRNO(fd >= 0);
   ScopedFdCloser fd_closer(&fd);
   off_t rc = lseek(fd, size + 1, SEEK_SET);
   TEST_AND_RETURN_FALSE_ERRNO(rc != static_cast<off_t>(-1));
   int return_code = ftruncate(fd, size);
   TEST_AND_RETURN_FALSE_ERRNO(return_code == 0);
   return true;
 }
+}  // namespace {}
 
-void DoSmallImageTest(bool full_kernel, bool full_rootfs, bool noop) {
+namespace {
+void DoSmallImageTest(bool full_kernel, bool full_rootfs, bool noop,
+                      bool post_sign) {
   string a_img, b_img;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/a_img.XXXXXX", &a_img, NULL));
   ScopedPathUnlinker a_img_unlinker(a_img);
   EXPECT_TRUE(utils::MakeTempFile("/tmp/b_img.XXXXXX", &b_img, NULL));
   ScopedPathUnlinker b_img_unlinker(b_img);
 
   CreateExtImageAtPath(a_img, NULL);
 
   int image_size = static_cast<int>(utils::FileSize(a_img));
 
@@ skipping 94 matching lines @@
 
     EXPECT_TRUE(
         DeltaDiffGenerator::GenerateDeltaUpdateFile(
             full_rootfs ? "" : a_mnt,
             full_rootfs ? "" : a_img,
             b_mnt,
             b_img,
             full_kernel ? "" : old_kernel,
             new_kernel,
             delta_path,
-            kUnittestPrivateKeyPath));
+            post_sign ? "" : kUnittestPrivateKeyPath));
+  }
+
+  if (post_sign) {
+    int signature_size;
+    {
+      const vector<char> data(1, 'x');
+      vector<char> hash;
+      ASSERT_TRUE(OmahaHashCalculator::RawHashOfData(data, &hash));
+      vector<char> signature;
+      ASSERT_TRUE(PayloadSigner::SignHash(hash,
+                                          kUnittestPrivateKeyPath,
+                                          &signature));
+      signature_size = signature.size();
+    }
+
+    vector<char> hash;
+    ASSERT_TRUE(PayloadSigner::HashPayloadForSigning(delta_path,
+                                                     signature_size,
+                                                     &hash));
+    vector<char> signature;
+    ASSERT_TRUE(PayloadSigner::SignHash(hash,
+                                        kUnittestPrivateKeyPath,
+                                        &signature));
+    ASSERT_TRUE(PayloadSigner::AddSignatureToPayload(delta_path,
+                                                     signature,
+                                                     delta_path));
   }
 
   // Read delta into memory.
   vector<char> delta;
   EXPECT_TRUE(utils::ReadFile(delta_path, &delta));
 
   uint64_t manifest_metadata_size;
 
   // Check the metadata.
   {
@@ skipping 122 matching lines @@
   vector<char> expected_new_rootfs_hash;
   EXPECT_EQ(image_size,
             OmahaHashCalculator::RawHashOfFile(b_img,
                                                image_size,
                                                &expected_new_rootfs_hash));
   EXPECT_TRUE(expected_new_rootfs_hash == new_rootfs_hash);
 }
 }
 
 TEST(DeltaPerformerTest, RunAsRootSmallImageTest) {
-  DoSmallImageTest(false, false, false);
+  DoSmallImageTest(false, false, false, false);
 }
 
 TEST(DeltaPerformerTest, RunAsRootFullKernelSmallImageTest) {
-  DoSmallImageTest(true, false, false);
+  DoSmallImageTest(true, false, false, false);
 }
 
 TEST(DeltaPerformerTest, RunAsRootFullSmallImageTest) {
-  DoSmallImageTest(true, true, false);
+  DoSmallImageTest(true, true, false, false);
 }
 
 TEST(DeltaPerformerTest, RunAsRootNoopSmallImageTest) {
-  DoSmallImageTest(false, false, true);
+  DoSmallImageTest(false, false, true, false);
+}
+
+TEST(DeltaPerformerTest, RunAsRootSmallImagePostSignTest) {
+  DoSmallImageTest(false, false, false, true);
 }
 
 TEST(DeltaPerformerTest, BadDeltaMagicTest) {
   PrefsMock prefs;
   DeltaPerformer performer(&prefs);
   EXPECT_EQ(0, performer.Open("/dev/null", 0, 0));
   EXPECT_TRUE(performer.OpenKernel("/dev/null"));
   EXPECT_EQ(4, performer.Write("junk", 4));
   EXPECT_EQ(8, performer.Write("morejunk", 8));
   EXPECT_LT(performer.Write("morejunk", 8), 0);
@@ skipping 10 matching lines @@
   op.clear_src_extents();
   *(op.add_src_extents()) = ExtentForRange(5, 3);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_dst_extents()) = ExtentForRange(20, 6);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_src_extents()) = ExtentForRange(19, 2);
   EXPECT_FALSE(DeltaPerformer::IsIdempotentOperation(op));
 }
 
 }  // namespace chromeos_update_engine