Merge cryptohome::RetrievedKeyData with cryptohome::KeyDefinition

chromeos/cryptohome/homedir_methods.cc

 // Copyright 2014 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/cryptohome/homedir_methods.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chromeos/dbus/cryptohome/key.pb.h"
 #include "chromeos/dbus/cryptohome/rpc.pb.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 
 #if defined(USE_SYSTEM_PROTOBUF)
 #include <google/protobuf/repeated_field.h>
 #else
 #include "third_party/protobuf/src/google/protobuf/repeated_field.h"
 #endif
 
 using chromeos::DBusThreadManager;
 using google::protobuf::RepeatedPtrField;
 
 namespace cryptohome {
 
 namespace {
 
 HomedirMethods* g_homedir_methods = NULL;
 
 void FillKeyProtobuf(const KeyDefinition& key_def, Key* key) {
-  key->set_secret(key_def.key);
+  key->set_secret(key_def.secret);
   KeyData* data = key->mutable_data();
+  DCHECK_EQ(KeyDefinition::TYPE_PASSWORD, key_def.type);
+  data->set_type(KeyData::KEY_TYPE_PASSWORD);
   data->set_label(key_def.label);
 
   if (key_def.revision > 0)
     data->set_revision(key_def.revision);
 
   if (key_def.privileges != 0) {
     KeyPrivileges* privileges = data->mutable_privileges();
     privileges->set_mount(key_def.privileges & PRIV_MOUNT);
     privileges->set_add(key_def.privileges & PRIV_ADD);
     privileges->set_remove(key_def.privileges & PRIV_REMOVE);
     privileges->set_update(key_def.privileges & PRIV_MIGRATE);
     privileges->set_authorized_update(key_def.privileges &
                                       PRIV_AUTHORIZED_UPDATE);
   }
 
-  if (key_def.encryption_key.empty() && key_def.signature_key.empty())
-    return;
+  for (std::vector<KeyDefinition::AuthorizationData>::const_iterator auth_it =
+          key_def.authorization_data.begin();
+       auth_it != key_def.authorization_data.end(); ++auth_it) {
+    KeyAuthorizationData* auth_data = data->add_authorization_data();
+    switch (auth_it->type) {
+      case KeyDefinition::AuthorizationData::TYPE_HMACSHA256:
+        auth_data->set_type(
+            KeyAuthorizationData::KEY_AUTHORIZATION_TYPE_HMACSHA256);
+        break;
+      case KeyDefinition::AuthorizationData::TYPE_AES256CBC_HMACSHA256:
+        auth_data->set_type(
+            KeyAuthorizationData::KEY_AUTHORIZATION_TYPE_AES256CBC_HMACSHA256);
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
 
-  KeyAuthorizationData* auth_data = data->add_authorization_data();
-  auth_data->set_type(KeyAuthorizationData::KEY_AUTHORIZATION_TYPE_HMACSHA256);
-  if (!key_def.encryption_key.empty()) {
-    KeyAuthorizationSecret* secret = auth_data->add_secrets();
-    secret->mutable_usage()->set_encrypt(true);
-    secret->set_symmetric_key(key_def.encryption_key);
+    for (std::vector<KeyDefinition::AuthorizationData::Secret>::const_iterator
+             secret_it = auth_it->secrets.begin();
+         secret_it != auth_it->secrets.end(); ++secret_it) {
+      KeyAuthorizationSecret* secret = auth_data->add_secrets();
+      secret->mutable_usage()->set_encrypt(secret_it->encrypt);
+      secret->mutable_usage()->set_sign(secret_it->sign);
+      if (!secret_it->symmetric_key.empty())
+        secret->set_symmetric_key(secret_it->symmetric_key);
+      if (!secret_it->public_key.empty())
+        secret->set_public_key(secret_it->public_key);
+      secret->set_wrapped(secret_it->wrapped);
+    }
   }
-  if (!key_def.signature_key.empty()) {
-    KeyAuthorizationSecret* secret = auth_data->add_secrets();
-    secret->mutable_usage()->set_sign(true);
-    secret->set_symmetric_key(key_def.signature_key);
+
+  if (!key_def.provider_data.empty()) {

[Darren Krahn, 2014/09/02 18:21:53]

nit: conditional not necessary

[bartfab (slow), 2014/09/04 10:14:18]

Done.

+    for (std::vector<KeyDefinition::ProviderData>::const_iterator it =
+             key_def.provider_data.begin(); it != key_def.provider_data.end();
+         ++it) {
+      KeyProviderData::Entry* entry =
+          data->mutable_provider_data()->add_entry();
+      entry->set_name(it->name);
+      if (it->number)
+        entry->set_number(*it->number);
+      if (it->bytes)
+        entry->set_bytes(*it->bytes);
+    }
   }
 }
 
 // Fill identification protobuffer.
 void FillIdentificationProtobuf(const Identification& id,
                                 cryptohome::AccountIdentifier* id_proto) {
   id_proto->set_email(id.user_id);
 }
 
 // Fill authorization protobuffer.
 void FillAuthorizationProtobuf(const Authorization& auth,
                                cryptohome::AuthorizationRequest* auth_proto) {
   Key* key = auth_proto->mutable_key();
   if (!auth.label.empty()) {
     key->mutable_data()->set_label(auth.label);
   }
   key->set_secret(auth.key);
 }
 
+void ParseAuthorizationDataProtobuf(
+    const KeyAuthorizationData& authorization_data_proto,
+    KeyDefinition::AuthorizationData* authorization_data) {
+  switch (authorization_data_proto.type()) {
+    case KeyAuthorizationData::KEY_AUTHORIZATION_TYPE_HMACSHA256:
+      authorization_data->type =
+          KeyDefinition::AuthorizationData::TYPE_HMACSHA256;
+      break;
+    case KeyAuthorizationData::KEY_AUTHORIZATION_TYPE_AES256CBC_HMACSHA256:
+      authorization_data->type =
+          KeyDefinition::AuthorizationData::TYPE_AES256CBC_HMACSHA256;
+      break;
+    default:
+      NOTREACHED();
+      return;
+  }
+
+  for (RepeatedPtrField<KeyAuthorizationSecret>::const_iterator it =
+          authorization_data_proto.secrets().begin();
+       it != authorization_data_proto.secrets().end(); ++it) {
+    authorization_data->secrets.push_back(
+        KeyDefinition::AuthorizationData::Secret(it->usage().encrypt(),
+                                                 it->usage().sign(),
+                                                 it->symmetric_key(),
+                                                 it->public_key(),
+                                                 it->wrapped()));
+  }
+}
+
 MountError MapError(CryptohomeErrorCode code) {
   switch (code) {
     case CRYPTOHOME_ERROR_NOT_SET:
       return MOUNT_ERROR_NONE;
     case CRYPTOHOME_ERROR_ACCOUNT_NOT_FOUND:
       return MOUNT_ERROR_USER_DOES_NOT_EXIST;
     case CRYPTOHOME_ERROR_NOT_IMPLEMENTED:
     case CRYPTOHOME_ERROR_MOUNT_FATAL:
     case CRYPTOHOME_ERROR_KEY_QUOTA_EXCEEDED:
     case CRYPTOHOME_ERROR_BACKING_STORE_FAILURE:
@@ skipping 160 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
  private:
   void OnGetKeyDataExCallback(const GetKeyDataCallback& callback,
                               chromeos::DBusMethodCallStatus call_status,
                               bool result,
                               const BaseReply& reply) {
     if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
-      callback.Run(false, MOUNT_ERROR_FATAL, ScopedVector<RetrievedKeyData>());
+      callback.Run(false, MOUNT_ERROR_FATAL, std::vector<KeyDefinition>());
       return;
     }
     if (reply.has_error()) {
       if (reply.error() != CRYPTOHOME_ERROR_NOT_SET) {
         callback.Run(false,
                      MapError(reply.error()),
-                     ScopedVector<RetrievedKeyData>());
+                     std::vector<KeyDefinition>());
         return;
       }
     }
 
     if (!reply.HasExtension(GetKeyDataReply::reply)) {
-      callback.Run(false, MOUNT_ERROR_FATAL, ScopedVector<RetrievedKeyData>());
+      callback.Run(false, MOUNT_ERROR_FATAL, std::vector<KeyDefinition>());
       return;
     }
 
     // Extract the contents of the |KeyData| protos returned.
-    const RepeatedPtrField<KeyData>& key_data_proto =
+    const RepeatedPtrField<KeyData>& key_data =
         reply.GetExtension(GetKeyDataReply::reply).key_data();
-    ScopedVector<RetrievedKeyData> key_data_list;
-    for (RepeatedPtrField<KeyData>::const_iterator it = key_data_proto.begin();
-         it != key_data_proto.end(); ++it) {
+    std::vector<KeyDefinition> key_definitions;
+    for (RepeatedPtrField<KeyData>::const_iterator it = key_data.begin();
+         it != key_data.end(); ++it) {
 
       // Extract |type|, |label| and |revision|.
       DCHECK_EQ(KeyData::KEY_TYPE_PASSWORD, it->type());
-      key_data_list.push_back(new RetrievedKeyData(
-          RetrievedKeyData::TYPE_PASSWORD,
-          it->label(),
-          it->revision()));
-      RetrievedKeyData* key_data = key_data_list.back();
+      key_definitions.push_back(KeyDefinition(std::string() /* secret */,
+                                              it->label(),
+                                              0 /* privileges */));
+      KeyDefinition& key_definition = key_definitions.back();
+      key_definition.revision = it->revision();
 
       // Extract |privileges|.
       const KeyPrivileges& privileges = it->privileges();
       if (privileges.mount())
-        key_data->privileges |= PRIV_MOUNT;
+        key_definition.privileges |= PRIV_MOUNT;
       if (privileges.add())
-        key_data->privileges |= PRIV_ADD;
+        key_definition.privileges |= PRIV_ADD;
       if (privileges.remove())
-        key_data->privileges |= PRIV_REMOVE;
+        key_definition.privileges |= PRIV_REMOVE;
       if (privileges.update())
-        key_data->privileges |= PRIV_MIGRATE;
+        key_definition.privileges |= PRIV_MIGRATE;
       if (privileges.authorized_update())
-        key_data->privileges |= PRIV_AUTHORIZED_UPDATE;
+        key_definition.privileges |= PRIV_AUTHORIZED_UPDATE;
 
       // Extract |authorization_data|.
       for (RepeatedPtrField<KeyAuthorizationData>::const_iterator auth_it =
                it->authorization_data().begin();
            auth_it != it->authorization_data().end(); ++auth_it) {
-        switch (auth_it->type()) {
-          case KeyAuthorizationData::KEY_AUTHORIZATION_TYPE_HMACSHA256:
-            key_data->authorization_types.push_back(
-                RetrievedKeyData::AUTHORIZATION_TYPE_HMACSHA256);
-            break;
-          case KeyAuthorizationData::
-                   KEY_AUTHORIZATION_TYPE_AES256CBC_HMACSHA256:
-            key_data->authorization_types.push_back(
-                RetrievedKeyData::AUTHORIZATION_TYPE_AES256CBC_HMACSHA256);
-            break;
-          default:
-            NOTREACHED();
-            break;
-        }
+        key_definition.authorization_data.push_back(
+            KeyDefinition::AuthorizationData());
+        ParseAuthorizationDataProtobuf(
+            *auth_it,
+            &key_definition.authorization_data.back());
       }
 
       // Extract |provider_data|.
       for (RepeatedPtrField<KeyProviderData::Entry>::const_iterator
               provider_data_it = it->provider_data().entry().begin();
            provider_data_it != it->provider_data().entry().end();
            ++provider_data_it) {
         // Extract |name|.
-        key_data->provider_data.push_back(
-            new RetrievedKeyData::ProviderData(provider_data_it->name()));
-        RetrievedKeyData::ProviderData* provider_data =
-            key_data->provider_data.back();
+        key_definition.provider_data.push_back(
+            KeyDefinition::ProviderData(provider_data_it->name()));
+        KeyDefinition::ProviderData& provider_data =
+            key_definition.provider_data.back();
 
         int data_items = 0;
 
         // Extract |number|.
         if (provider_data_it->has_number()) {
-          provider_data->number.reset(new int64(provider_data_it->number()));
+          provider_data.number.reset(new int64(provider_data_it->number()));
           ++data_items;
         }
 
         // Extract |bytes|.
         if (provider_data_it->has_bytes()) {
-          provider_data->bytes.reset(
+          provider_data.bytes.reset(
               new std::string(provider_data_it->bytes()));
           ++data_items;
         }
 
         DCHECK_EQ(1, data_items);
       }
     }
 
-    callback.Run(true, MOUNT_ERROR_NONE, key_data_list.Pass());
+    callback.Run(true, MOUNT_ERROR_NONE, key_definitions);
   }
 
   void OnMountExCallback(const MountCallback& callback,
                          chromeos::DBusMethodCallStatus call_status,
                          bool result,
                          const BaseReply& reply) {
     if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
       callback.Run(false, MOUNT_ERROR_FATAL, std::string());
       return;
     }
@@ skipping 65 matching lines @@
   }
   delete g_homedir_methods;
   g_homedir_methods = NULL;
   VLOG(1) << "HomedirMethods Shutdown completed";
 }
 
 // static
 HomedirMethods* HomedirMethods::GetInstance() { return g_homedir_methods; }
 
 }  // namespace cryptohome