Adds the necessary changes to tpm_init to allow triggered initialization.

tpm.h

 // Copyright (c) 2009-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.
 
 // Tpm - class for handling init TPM initialization for Chrome OS
 
 #include <base/lock.h>
 #include <base/logging.h>
 #include <base/scoped_ptr.h>
 #include <chromeos/utility.h>
 #include <trousers/tss.h>
 #include <trousers/trousers.h>
 
 #include "crypto.h"
+#include "platform.h"
 #include "secure_blob.h"
+#include "tpm_status.pb.h"
 
 #ifndef TPM_INIT_TPM_H_
 #define TPM_INIT_TPM_H_
 
 namespace tpm_init {
 
 class Tpm {
  public:
 
   // Default constructor
   Tpm();
 
   virtual ~Tpm();
 
   // Initializes the Tpm instance
   //
   // Parameters
   virtual bool Init();
 
-  // Tries to connect to the TPM
-  virtual bool Connect();
-
-  // Returns true if this instance is connected to the TPM
-  virtual bool IsConnected();
-
-  // Disconnects from the TPM
-  virtual void Disconnect();
-
   // Returns the number of simultaneously-loaded RSA keys that this TPM supports
   int GetMaxRsaKeyCount();
 
   // Returns the owner password if this instance was used to take ownership.
   // This will only occur when the TPM is unowned, which will be on OOBE
   //
   // Parameters
   //   owner_password (OUT) - The random owner password used
   bool GetOwnerPassword(chromeos::Blob* owner_password);
 
+  // Clears the owner password from storage
+  void ClearStoredOwnerPassword();
+
   // Returns whether or not the TPM is enabled.  This method call returns a
   // cached result because querying the TPM directly will block if ownership is
   // currently being taken (such as on a separate thread).
   bool IsEnabled() const { return !is_disabled_; }
 
   // Returns whether or not the TPM is owned.  This method call returns a cached
   // result because querying the TPM directly will block if ownership is
   // currently being taken (such as on a separate thread).
   bool IsOwned() const { return is_owned_; }
 
   // Returns whether or not the SRK is available
   bool IsSrkAvailable() const { return is_srk_available_; }
 
   // Returns whether or not the TPM is being owned
   bool IsBeingOwned() const { return is_being_owned_; }
 
   // Runs the TPM initialization sequence.  This may take a long time due to the
   // call to Tspi_TPM_TakeOwnership.
   bool InitializeTpm(bool* OUT_took_ownership);
 
   // Gets random bytes from the TPM
   //
   // Parameters
   //   length - The number of bytes to get
   //   data (OUT) - The random data from the TPM
   bool GetRandomData(size_t length, chromeos::Blob* data);
 
  private:
+  // Tries to connect to the TPM
+  virtual TSS_HCONTEXT Connect();
+
+  // Disconnects from the TPM
+  virtual void Disconnect(TSS_HCONTEXT context_handle);
+
+  // Gets a handle to the SRK
+  bool LoadSrk(TSS_HCONTEXT context_handle, TSS_HKEY* srk_handle,
+               TSS_RESULT* result);
+
+  // Loads the contents of the file specified into a blob
+  bool LoadFileBytes(const FilePath& path, chromeos::Blob* blob);
+
+  // Stores the TPM owner password to the TpmStatus object
+  bool StoreOwnerPassword(const chromeos::Blob& owner_password,
+                          TpmStatus* tpm_status);
+
+  // Retrieves the TPM owner password
+  bool LoadOwnerPassword(const TpmStatus& tpm_status,
+                         chromeos::Blob* owner_password);
+
+  // Loads the TpmStatus object
+  bool LoadTpmStatus(TpmStatus* serialized);
+
+  // Saves the TpmStatus object
+  bool StoreTpmStatus(const TpmStatus& serialized);
+
   // Attempts to connect to tcsd
   //
   // Parameters
   //   context_handle (OUT) - The context handle to the session on success
   bool OpenAndConnectTpm(TSS_HCONTEXT* context_handle);
 
   // Returns the maximum simultaneously-loaded RSA key count for the TPM
   // specified by the context handle
   //
   // Parameters
@@ skipping 17 matching lines @@
   //   owned (OUT) - Whether the TPM is owned
   void IsEnabledOwnedCheckViaContext(TSS_HCONTEXT context_handle,
                                      bool* enabled, bool* owned);
 
   // Attempts to create the endorsement key in the TPM
   //
   // Parameters
   //   context_handle - The context handle for the TPM session
   bool CreateEndorsementKey(TSS_HCONTEXT context_handle);
 
+  // Delegates ownership authority
+  //
+  // Parameters
+  //   context_handle - The context handle for the TPM session
+  bool DelegateTpmOwnership(TSS_HCONTEXT context_handle, TSS_HTPM tpm_handle,
+                            SecureBlob* delegation_blob);
+
   // Checks to see if the endorsement key is available by attempting to get its
   // public key
   //
   // Parameters
   //   context_handle - The context handle for the TPM session
   bool IsEndorsementKeyAvailable(TSS_HCONTEXT context_handle);
 
   // Creates a random owner password
   //
   // Parameters
@@ skipping 52 matching lines @@
   bool GetTpmWithAuth(TSS_HCONTEXT context_handle,
                       const SecureBlob& owner_password,
                       TSS_HTPM* tpm_handle);
 
   // Test the TPM auth by calling Tspi_TPM_GetStatus
   //
   // Parameters
   //   tpm_handle = The TPM handle
   bool TestTpmAuth(TSS_HTPM tpm_handle);
 
-  // The context handle for this TPM session
-  TSS_HCONTEXT context_handle_;
-
   // The default Crypto instance to use (for generating the random owner
   // password)
   scoped_ptr<Crypto> default_crypto_;
 
   // The actual Crypto instance to use
   Crypto* crypto_;
 
+  // The default Platform instance to use
+  scoped_ptr<Platform> default_platform_;
+
+  // The actual Platform instance to use
+  Platform* platform_;
+
   // If TPM ownership is taken, owner_password_ contains the password used
   SecureBlob owner_password_;
 
   // Used to provide thread-safe access to owner_password_, as it is set in the
   // initialization background thread.
   Lock password_sync_lock_;
 
   // Indicates if the TPM is disabled
   bool is_disabled_;
 
   // Indicates if the TPM is owned
   bool is_owned_;
 
   // Indicates if the SRK is available
   bool is_srk_available_;
 
   // Indicates if the TPM is being owned
   bool is_being_owned_;
 
   DISALLOW_COPY_AND_ASSIGN(Tpm);
 };
 
 }  // namespace tpm_init
 
 #endif  // TPM_INIT_TPM_H_