Do a better job at faking simple challenge signatures.

chromeos/dbus/fake_cryptohome_client.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 "chromeos/dbus/fake_cryptohome_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "chromeos/attestation/attestation.pb.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/dbus/cryptohome/key.pb.h"
 #include "chromeos/dbus/cryptohome/rpc.pb.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "third_party/protobuf/src/google/protobuf/io/coded_stream.h"
 #include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream.h"
 #include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"
 
 namespace chromeos {
 
+namespace {
+// Signature nonces are twenty bytes. This matches the attestation code.
+constexpr char kTwentyBytesNonce[] = "+addtwentybytesnonce";
+// A symbolic signature.
+constexpr char kSignature[] = "signed";
+}  // namespace
+
 FakeCryptohomeClient::FakeCryptohomeClient()
     : service_is_available_(true),
       async_call_id_(1),
       unmount_result_(true),
       system_salt_(GetStubSystemSalt()),
       weak_ptr_factory_(this) {
   base::FilePath cache_path;
   locked_ = PathService::Get(chromeos::FILE_INSTALL_ATTRIBUTES, &cache_path) &&
             base::PathExists(cache_path);
 }
@@ skipping 36 matching lines @@
 
 bool FakeCryptohomeClient::Unmount(bool* success) {
   *success = unmount_result_;
   return true;
 }
 
 void FakeCryptohomeClient::AsyncCheckKey(
     const cryptohome::Identification& cryptohome_id,
     const std::string& key,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::AsyncMigrateKey(
     const cryptohome::Identification& cryptohome_id,
     const std::string& from_key,
     const std::string& to_key,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::AsyncRemove(
     const cryptohome::Identification& cryptohome_id,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::RenameCryptohome(
     const cryptohome::Identification& cryptohome_id_from,
     const cryptohome::Identification& cryptohome_id_to,
     const ProtobufMethodCallback& callback) {
   cryptohome::BaseReply reply;
   ReturnProtobufMethodCallback(reply, callback);
 }
 
@@ skipping 28 matching lines @@
 std::string FakeCryptohomeClient::BlockingGetSanitizedUsername(
     const cryptohome::Identification& cryptohome_id) {
   return GetStubSanitizedUsername(cryptohome_id);
 }
 
 void FakeCryptohomeClient::AsyncMount(
     const cryptohome::Identification& cryptohome_id,
     const std::string& key,
     int flags,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::AsyncAddKey(
     const cryptohome::Identification& cryptohome_id,
     const std::string& key,
     const std::string& new_key,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::AsyncMountGuest(
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::AsyncMountPublic(
     const cryptohome::Identification& public_mount_id,
     int flags,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::TpmIsReady(
     const BoolDBusMethodCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
 }
 
 void FakeCryptohomeClient::TpmIsEnabled(
     const BoolDBusMethodCallback& callback) {
@@ skipping 182 matching lines @@
 
 void FakeCryptohomeClient::TpmAttestationIsEnrolled(
     const BoolDBusMethodCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
 }
 
 void FakeCryptohomeClient::AsyncTpmAttestationCreateEnrollRequest(
     chromeos::attestation::PrivacyCAType pca_type,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, true);
+  ReturnAsyncMethodData(callback, std::string());
 }
 
 void FakeCryptohomeClient::AsyncTpmAttestationEnroll(
     chromeos::attestation::PrivacyCAType pca_type,
     const std::string& pca_response,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, false);
+  ReturnAsyncMethodResult(callback);
 }
 
 void FakeCryptohomeClient::AsyncTpmAttestationCreateCertRequest(
     chromeos::attestation::PrivacyCAType pca_type,
     attestation::AttestationCertificateProfile certificate_profile,
     const cryptohome::Identification& cryptohome_id,
     const std::string& request_origin,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, true);
+  ReturnAsyncMethodData(callback, std::string());
 }
 
 void FakeCryptohomeClient::AsyncTpmAttestationFinishCertRequest(
     const std::string& pca_response,
     attestation::AttestationKeyType key_type,
     const cryptohome::Identification& cryptohome_id,
     const std::string& key_name,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, true);
+  ReturnAsyncMethodData(callback, std::string());
 }
 
 void FakeCryptohomeClient::TpmAttestationDoesKeyExist(
     attestation::AttestationKeyType key_type,
     const cryptohome::Identification& cryptohome_id,
     const std::string& key_name,
     const BoolDBusMethodCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
 }
@@ skipping 16 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
 }
 
 void FakeCryptohomeClient::TpmAttestationRegisterKey(
     attestation::AttestationKeyType key_type,
     const cryptohome::Identification& cryptohome_id,
     const std::string& key_name,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, true);
+  ReturnAsyncMethodData(callback, std::string());
 }
 
 void FakeCryptohomeClient::TpmAttestationSignEnterpriseChallenge(
     attestation::AttestationKeyType key_type,
     const cryptohome::Identification& cryptohome_id,
     const std::string& key_name,
     const std::string& domain,
     const std::string& device_id,
     attestation::AttestationChallengeOptions options,
     const std::string& challenge,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, true);
+  ReturnAsyncMethodData(callback, std::string());
 }
 
 void FakeCryptohomeClient::TpmAttestationSignSimpleChallenge(
     attestation::AttestationKeyType key_type,
     const cryptohome::Identification& cryptohome_id,
     const std::string& key_name,
     const std::string& challenge,
     const AsyncMethodCallback& callback) {
-  ReturnAsyncMethodResult(callback, true);
+  chromeos::attestation::SignedData signed_data;
+  signed_data.set_data(challenge + kTwentyBytesNonce);
+  signed_data.set_signature(kSignature);
+  ReturnAsyncMethodData(callback, signed_data.SerializeAsString());
 }
 
 void FakeCryptohomeClient::TpmAttestationGetKeyPayload(
     attestation::AttestationKeyType key_type,
     const cryptohome::Identification& cryptohome_id,
     const std::string& key_name,
     const DataMethodCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
@@ skipping 118 matching lines @@
 }
 
 void FakeCryptohomeClient::ReturnProtobufMethodCallback(
     const cryptohome::BaseReply& reply,
     const ProtobufMethodCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true, reply));
 }
 
 void FakeCryptohomeClient::ReturnAsyncMethodResult(
-    const AsyncMethodCallback& callback,
-    bool returns_data) {
+    const AsyncMethodCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeCryptohomeClient::ReturnAsyncMethodResultInternal,
-                 weak_ptr_factory_.GetWeakPtr(), callback, returns_data));
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void FakeCryptohomeClient::ReturnAsyncMethodData(
+    const AsyncMethodCallback& callback,
+    const std::string& data) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeCryptohomeClient::ReturnAsyncMethodDataInternal,
+                 weak_ptr_factory_.GetWeakPtr(), callback, data));
 }
 
 void FakeCryptohomeClient::ReturnAsyncMethodResultInternal(
-    const AsyncMethodCallback& callback,
-    bool returns_data) {
+    const AsyncMethodCallback& callback) {
   callback.Run(async_call_id_);
-  if (!returns_data && !async_call_status_handler_.is_null()) {
+  if (!async_call_status_handler_.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(async_call_status_handler_, async_call_id_, true,
                               cryptohome::MOUNT_ERROR_NONE));
-  } else if (returns_data && !async_call_status_data_handler_.is_null()) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(async_call_status_data_handler_, async_call_id_,
-                              true, std::string()));
   }
   ++async_call_id_;
 }
+
+void FakeCryptohomeClient::ReturnAsyncMethodDataInternal(
+    const AsyncMethodCallback& callback,
+    const std::string& data) {
+  callback.Run(async_call_id_);
+  if (!async_call_status_data_handler_.is_null()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(async_call_status_data_handler_, async_call_id_,
+                              true, data));
+  }
+  ++async_call_id_;
+}
 
 }  // namespace chromeos