Added dbus bindings for new cryptohomed attestation APIs.

chromeos/dbus/cryptohome_client.cc

 // Copyright (c) 2012 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/cryptohome_client.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/blocking_method_caller.h"
@@ skipping 512 matching lines @@
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignEnterpriseChallenge);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     writer.AppendString(domain);
-    writer.AppendString(device_id);
+    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(device_id.data()),
+                              device_id.size());
     bool include_signed_public_key = (options & INCLUDE_SIGNED_PUBLIC_KEY);
     writer.AppendBool(include_signed_public_key);
-    writer.AppendString(challenge);
+    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
+                              challenge.size());
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignSimpleChallenge(
       AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignEnterpriseChallenge);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
-    writer.AppendString(challenge);
+    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
+                              challenge.size());
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
+  // CryptohomeClient override.
+  virtual void TpmAttestationGetKeyPayload(
+      AttestationKeyType key_type,
+      const std::string& key_name,
+      const DataMethodCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(
+        cryptohome::kCryptohomeInterface,
+        cryptohome::kCryptohomeTpmAttestationGetKeyPayload);
+    dbus::MessageWriter writer(&method_call);
+    bool is_user_specific = (key_type == USER_KEY);
+    writer.AppendBool(is_user_specific);
+    writer.AppendString(key_name);
+    proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                       base::Bind(&CryptohomeClientImpl::OnDataMethod,
+                                  weak_ptr_factory_.GetWeakPtr(),
+                                  callback));
+  }
+
+  // CryptohomeClient override.
+  virtual void TpmAttestationSetKeyPayload(
+      AttestationKeyType key_type,
+      const std::string& key_name,
+      const std::string& payload,
+      const BoolDBusMethodCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(
+        cryptohome::kCryptohomeInterface,
+        cryptohome::kCryptohomeTpmAttestationSetKeyPayload);
+    dbus::MessageWriter writer(&method_call);
+    bool is_user_specific = (key_type == USER_KEY);
+    writer.AppendBool(is_user_specific);
+    writer.AppendString(key_name);
+    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(payload.data()),
+                              payload.size());
+    CallBoolMethod(&method_call, callback);
+  }
+
  private:
   // Handles the result of AsyncXXX methods.
   void OnAsyncMethodCall(const AsyncMethodCallback& callback,
                          dbus::Response* response) {
     if (!response)
       return;
     dbus::MessageReader reader(response);
     int async_id = 0;
     if (!reader.PopInt32(&async_id)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
@@ skipping 74 matching lines @@
   }
 
   // Handles responses for methods with a bool result and data.
   void OnDataMethod(const DataMethodCallback& callback,
                     dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
       return;
     }
     dbus::MessageReader reader(response);
+    uint8* data_buffer = NULL;
+    size_t data_length = 0;
     bool result = false;
-    if (!reader.PopBool(&result)) {
+    if (!reader.PopArrayOfBytes(&data_buffer, &data_length) ||
+        !reader.PopBool(&result)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
       return;
     }
-    std::string data;
-    if (!reader.PopString(&data)) {
-      callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
-      return;
-    }
+    std::string data(reinterpret_cast<char*>(data_buffer), data_length);
     callback.Run(DBUS_METHOD_CALL_SUCCESS, result, data);
   }
 
   // Handles responses for Pkcs11GetTpmtTokenInfo.
   void OnPkcs11GetTpmTokenInfo(const Pkcs11GetTpmTokenInfoCallback& callback,
                                dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string());
       return;
     }
@@ skipping 386 matching lines @@
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignSimpleChallenge(
       AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
+  virtual void TpmAttestationGetKeyPayload(
+      AttestationKeyType key_type,
+      const std::string& key_name,
+      const DataMethodCallback& callback) OVERRIDE {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
+  }
+
+  virtual void TpmAttestationSetKeyPayload(
+      AttestationKeyType key_type,
+      const std::string& key_name,
+      const std::string& payload,
+      const BoolDBusMethodCallback& callback) OVERRIDE {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
+  }
+
+
  private:
   // Posts tasks which return fake results to the UI thread.
   void ReturnAsyncMethodResult(const AsyncMethodCallback& callback,
                                bool returns_data) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&CryptohomeClientStubImpl::ReturnAsyncMethodResultInternal,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    returns_data));
@@ skipping 44 matching lines @@
 // static
 CryptohomeClient* CryptohomeClient::Create(DBusClientImplementationType type,
                                            dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new CryptohomeClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new CryptohomeClientStubImpl();
 }
 
 }  // namespace chromeos