AU: detect failure when using public key verification

delta_performer.cc

 // Copyright (c) 2010 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 "update_engine/delta_performer.h"
 
 #include <endian.h>
 #include <errno.h>
 
 #include <algorithm>
@@ skipping 554 matching lines @@
       << "Unable to store the signed hash context.";
   LOG(INFO) << "Extracted signature data of size "
             << manifest_.signatures_size() << " at "
             << manifest_.signatures_offset();
   return true;
 }
 
 bool DeltaPerformer::VerifyPayload(
     const string& public_key_path,
     const std::string& update_check_response_hash,
-    const uint64_t update_check_response_size) {
+    const uint64_t update_check_response_size,
+    bool* signature_failed) {
   string key_path = public_key_path;
   if (key_path.empty()) {
     key_path = kUpdatePayloadPublicKeyPath;
   }
   LOG(INFO) << "Verifying delta payload. Public key path: " << key_path;
 
   // Verifies the download hash.
   const string& download_hash_data = hash_calculator_.hash();
   TEST_AND_RETURN_FALSE(!download_hash_data.empty());
   TEST_AND_RETURN_FALSE(download_hash_data == update_check_response_hash);
 
   // Verifies the download size.
   TEST_AND_RETURN_FALSE(update_check_response_size ==
                         manifest_metadata_size_ + buffer_offset_);
 
   // Verifies the signed payload hash.
   if (!utils::FileExists(key_path.c_str())) {

[petkov, 2011/03/30 21:04:42]

I assume you have full confidence in the correctness of the
TEST_AND_RETURN_FALSE statements between this if and the new if? :-)

[adlr, 2011/03/30 21:52:19]

Good point! I was thinking we should really expect all these other things to
succeed, but I think you're right that we should allow them to fail. Changed.

     LOG(WARNING) << "Not verifying signed delta payload -- missing public key.";
     return true;
   }
   TEST_AND_RETURN_FALSE(!signatures_message_data_.empty());
   vector<char> signed_hash_data;
   TEST_AND_RETURN_FALSE(PayloadSigner::VerifySignature(signatures_message_data_,

[petkov, 2011/03/30 21:04:42]

If signatures get mixed up this will fail first. So you probably want to
conditionalize this code too.

[adlr, 2011/03/30 21:52:19]

Done.

                                                        key_path,
                                                        &signed_hash_data));
   OmahaHashCalculator signed_hasher;
   TEST_AND_RETURN_FALSE(signed_hasher.SetContext(signed_hash_context_));
   TEST_AND_RETURN_FALSE(signed_hasher.Finalize());
   vector<char> hash_data = signed_hasher.raw_hash();
   PayloadSigner::PadRSA2048SHA256Hash(&hash_data);
   TEST_AND_RETURN_FALSE(!hash_data.empty());
-  TEST_AND_RETURN_FALSE(hash_data == signed_hash_data);
+  if (hash_data != signed_hash_data) {
+    LOG(ERROR) << "Public key verificaion failed. This is non-fatal. "
+        "Attached Signature:";
+    utils::HexDumpVector(signed_hash_data);
+    LOG(ERROR) << "Computed Signature:";
+    utils::HexDumpVector(hash_data);
+    if (signature_failed) {
+      *signature_failed = true;
+    }
+  }
   return true;
 }
 
 bool DeltaPerformer::GetNewPartitionInfo(uint64_t* kernel_size,
                                          vector<char>* kernel_hash,
                                          uint64_t* rootfs_size,
                                          vector<char>* rootfs_hash) {
   TEST_AND_RETURN_FALSE(manifest_valid_ &&
                         manifest_.has_new_kernel_info() &&
                         manifest_.has_new_rootfs_info());
@@ skipping 146 matching lines @@
   if (prefs_->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures)) {
     resumed_update_failures++;
   } else {
     resumed_update_failures = 1;
   }
   prefs_->SetInt64(kPrefsResumedUpdateFailures, resumed_update_failures);
   return true;
 }
 
 }  // namespace chromeos_update_engine