[cros] Add *Safe methods to the ownership API

drive_login.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 <dlfcn.h>
 #include <glib-object.h>
 #include <stdlib.h>
 
 #include <iostream>  // NOLINT
 #include <vector>
 
 #include <base/at_exit.h>
 #include <base/crypto/rsa_private_key.h>
 #include <base/crypto/signature_creator.h>
 #include <base/crypto/signature_verifier.h>
 #include <base/command_line.h>
 #include <base/logging.h>
 #include <base/file_path.h>
 #include <base/file_util.h>
 #include <base/nss_util.h>
 #include <base/scoped_temp_dir.h>
+#include <base/string_util.h>
 #include <base/stringprintf.h>
 
 #include "chromeos_cros_api.h"  // NOLINT
 #include "chromeos_login.h"
 #include "monitor_utils.h" //NOLINT
 
 namespace {
 static const char kEmit[] = "emit-login-prompt-ready";
 static const char kStartSession[] = "start-session";
 static const char kStopSession[] = "stop-session";
 static const char kSetOwnerKey[] = "set-owner-key";
 static const char kWhitelist[] = "whitelist";
 static const char kUnwhitelist[] = "unwhitelist";
 static const char kCheckWhitelist[] = "check-whitelist";
 static const char kEnumerate[] = "enumerate-whitelisted";
+static const char kStoreProperty[] = "store-property";
+static const char kRetrieveProperty[] = "retrieve-property";
 
 class ClientLoop {
  public:
   ClientLoop()
       : loop_(NULL),
         connection_(NULL) { }
 
   virtual ~ClientLoop() {
     if (connection_) {
       chromeos::DisconnectSession(connection_);
@@ skipping 155 matching lines @@
       LOG(FATAL) << "Starting session failed.";
   }
 
   // Really have to do this after clearing owner key, starting BWSI session.
   // Note that Chrome will get the signal that this has been done and CHECK.
   if (cl->HasSwitch(kSetOwnerKey)) {
     std::vector<uint8> pubkey;
     if (!GenerateOwnerKey(&pubkey))
       LOG(FATAL) << "Couldn't generate fakey owner key";
 
+    chromeos::CryptoBlob* blob = chromeos::CreateCryptoBlob(&pubkey[0],
+                                                            pubkey.size());
+
     ClientLoop client_loop;
     client_loop.Initialize();
 
-    if (!chromeos::SetOwnerKey(pubkey)) {
+    if (!chromeos::SetOwnerKeySafe(blob)) {
       LOG(FATAL) << "Could not send SetOwnerKey?";
     }
     client_loop.Run();
     LOG(INFO) << (client_loop.what_happened() == chromeos::SetKeySuccess ?
                   "Successfully set owner key" : "Didn't set owner key");
-    exit(0);
+    chromeos::FreeCryptoBlob(blob);
   }
   if (cl->HasSwitch(kWhitelist)) {
     scoped_ptr<base::RSAPrivateKey> private_key(
         GetPrivateKey(FilePath(chromeos::kOwnerKeyFile)));
 
     std::string name = cl->GetSwitchValueASCII(kWhitelist);
     std::vector<uint8> sig;
     if (!Sign(name, private_key.get(), &sig))
       LOG(FATAL) << "Can't sign " << name;
     else
       LOG(INFO) << "Signature is " << sig.size();
 
     ClientLoop client_loop;
     client_loop.Initialize();
 
-    if (!chromeos::Whitelist(name.c_str(), sig))
+    chromeos::CryptoBlob* blob = chromeos::CreateCryptoBlob(&sig[0],
+                                                            sig.size());
+
+    if (!chromeos::WhitelistSafe(name.c_str(), blob))
       LOG(FATAL) << "Could not send SetOwnerKey?";
 
     client_loop.Run();
     LOG(INFO) << (client_loop.what_happened() == chromeos::WhitelistOpSuccess ?
                   "Whitelisted " : "Failed to whitelist ") << name;
-    exit(0);
+    chromeos::FreeCryptoBlob(blob);
   }
   if (cl->HasSwitch(kUnwhitelist)) {
     scoped_ptr<base::RSAPrivateKey> private_key(
         GetPrivateKey(FilePath(chromeos::kOwnerKeyFile)));
 
     std::string name = cl->GetSwitchValueASCII(kUnwhitelist);
     std::vector<uint8> sig;
     if (!Sign(name, private_key.get(), &sig))
       LOG(FATAL) << "Can't sign " << name;
 
     ClientLoop client_loop;
     client_loop.Initialize();
 
-    if (!chromeos::Unwhitelist(name.c_str(), sig))
-      LOG(FATAL) << "Could not send SetOwnerKey?";
+    chromeos::CryptoBlob* blob = chromeos::CreateCryptoBlob(&sig[0],
+                                                            sig.size());
+
+    if (!chromeos::UnwhitelistSafe(name.c_str(), blob))
+      LOG(FATAL) << "Could not send UnwhitelistSafe?";
 
     client_loop.Run();
     LOG(INFO) << (client_loop.what_happened() == chromeos::WhitelistOpSuccess ?
                   "Whitelisted " : "Failed to whitelist ") << name;
-    exit(0);
+    chromeos::FreeCryptoBlob(blob);
   }
   if (cl->HasSwitch(kEnumerate)) {
-    std::vector<std::string> whitelisted;
-    if (!chromeos::EnumerateWhitelisted(&whitelisted)) {
+    chromeos::UserList* whitelisted = NULL;
+    if (!chromeos::EnumerateWhitelistedSafe(&whitelisted)) {
       LOG(FATAL) << "Could not enumerate the whitelisted";
     }
-    std::vector<std::string>::iterator it;
 
-    for (it = whitelisted.begin(); it < whitelisted.end(); ++it)
-      LOG(INFO) << *it << " is whitelisted";
+    for (int i = 0; i < whitelisted->num_users; i++)
+      LOG(INFO) << whitelisted->users[i] << " is whitelisted";
 
-    exit(0);
+    chromeos::FreeUserList(whitelisted);
   }
   if (cl->HasSwitch(kCheckWhitelist)) {
     std::string name = cl->GetSwitchValueASCII(kCheckWhitelist);
+    chromeos::CryptoBlob* sig;
+
+    if (!chromeos::CheckWhitelistSafe(name.c_str(), &sig))
+      LOG(WARNING) << name << " not on whitelist.";
+    else {
+      LOG(INFO) << name << " is on the whitelist.";
+      chromeos::FreeCryptoBlob(sig);
+    }
+  }
+  if (cl->HasSwitch(kStoreProperty)) {
+    scoped_ptr<base::RSAPrivateKey> private_key(
+        GetPrivateKey(FilePath(chromeos::kOwnerKeyFile)));
+
+    std::string keyval = cl->GetSwitchValueASCII(kStoreProperty);
     std::vector<uint8> sig;
+    if (!Sign(keyval, private_key.get(), &sig))
+      LOG(FATAL) << "Can't sign " << keyval;
+    else
+      LOG(INFO) << "Signature is " << sig.size();
 
-    if (!chromeos::CheckWhitelist(name.c_str(), &sig))
-      LOG(WARNING) << name << " not on whitelist.";
-    else
-      LOG(INFO) << name << " is on the whitelist.";
+    ClientLoop client_loop;
+    client_loop.Initialize();
 
-    exit(0);
+    std::vector<std::string> pair;
+    SplitString(keyval, '=', &pair);
+    chromeos::Property* prop = chromeos::CreateProperty(pair[0].c_str(),
+                                                        pair[1].c_str(),
+                                                        &sig[0],
+                                                        sig.size());
+    if (!chromeos::StorePropertySafe(prop))
+      LOG(FATAL) << "Could not send StorePropertySafe?";
+
+    client_loop.Run();
+    LOG(INFO) << (client_loop.what_happened() == chromeos::PropertyOpSuccess ?
+                  "Stored " : "Failed to store ") << keyval;
+    chromeos::FreeProperty(prop);
+  }
+  if (cl->HasSwitch(kRetrieveProperty)) {
+    std::string name = cl->GetSwitchValueASCII(kRetrieveProperty);
+    chromeos::Property* prop;
+
+    if (!chromeos::RetrievePropertySafe(name.c_str(), &prop))
+      LOG(WARNING) << name << " not stored.";
+    else {
+      LOG(INFO) << prop->name << "=" << prop->value;
+      chromeos::FreeProperty(prop);
+    }
   }
 
   return 0;
 }