Upgrade to tpm-emulator version 0.7.

tpm/tpm_cmd_handler.c

-/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
- * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
- *                    Swiss Federal Institute of Technology (ETH) Zurich
+/* Software-based Trusted Platform Module (TPM) Emulator
+ * Copyright (C) 2004-2010 Mario Strasser <mast@gmx.net>
  *
  * This module is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
  * by the Free Software Foundation; either version 2 of the License,
  * or (at your option) any later version.
  *
  * This module is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * $Id$
+ * $Id: tpm_cmd_handler.c 377 2010-02-16 14:52:57Z mast $
  */
 
 #include "tpm_marshalling.h"
 #include "tpm_commands.h"
 #include "crypto/sha1.h"
 #include "crypto/hmac.h"
 #include "tpm_data.h"
 #include "tpm_handles.h"
 
+#ifdef MTM_EMULATOR
+#include "mtm/mtm_commands.h"
+#endif
+
 UINT32 tpm_get_in_param_offset(TPM_COMMAND_CODE ordinal)
 {
   switch (ordinal) {
     case TPM_ORD_ActivateIdentity:
     case TPM_ORD_ChangeAuth:
     case TPM_ORD_ChangeAuthAsymStart:
     case TPM_ORD_CMK_ConvertMigration:
     case TPM_ORD_CMK_CreateBlob:
     case TPM_ORD_CMK_CreateKey:
     case TPM_ORD_ConvertMigrationBlob:
@@ skipping 319 matching lines @@
   BYTE *resp = NULL;
   TPM_RESULT res;
   /* unmarshal input */
   ptr = req->param;
   len = req->paramSize;
   if (tpm_unmarshal_TPM_CAPABILITY_AREA(&ptr, &len, &capArea)
       || tpm_unmarshal_UINT32(&ptr, &len, &subCapSize)
       || tpm_unmarshal_BLOB(&ptr, &len, &subCap, subCapSize)
       || len != 0) return TPM_BAD_PARAMETER;
   /* execute command */
+#ifdef MTM_EMULATOR
+  res = MTM_GetCapability(capArea, subCapSize, subCap, &respSize, &resp);
+#else
   res = TPM_GetCapability(capArea, subCapSize, subCap, &respSize, &resp);
+#endif
   if (res != TPM_SUCCESS) return res;
   /* marshal output */
   rsp->paramSize = len = 4 + respSize;
   rsp->param = ptr = tpm_malloc(len);
   if (ptr == NULL
       || tpm_marshal_UINT32(&ptr, &len, respSize)
       || tpm_marshal_BLOB(&ptr, &len, resp, respSize)) {
     tpm_free(rsp->param);
     res = TPM_FAIL;
   }
@@ skipping 1457 matching lines @@
   TPM_DIGEST inDigest;
   TPM_PCRVALUE outDigest;
   TPM_RESULT res;
   /* unmarshal input */
   ptr = req->param;
   len = req->paramSize;
   if (tpm_unmarshal_TPM_PCRINDEX(&ptr, &len, &pcrNum)
       || tpm_unmarshal_TPM_DIGEST(&ptr, &len, &inDigest)
       || len != 0) return TPM_BAD_PARAMETER;
   /* execute command */
+#ifdef MTM_EMULATOR
+  res = MTM_Extend(pcrNum, &inDigest, &outDigest);
+#else
   res = TPM_Extend(pcrNum, &inDigest, &outDigest);
+#endif
   if (res != TPM_SUCCESS) return res;
   /* marshal output */
   rsp->paramSize = len = 20;
   rsp->param = ptr = tpm_malloc(len);
   if (ptr == NULL
       || tpm_marshal_TPM_PCRVALUE(&ptr, &len, &outDigest)) {
     tpm_free(rsp->param);
     res = TPM_FAIL;
   }
   return res;
@@ skipping 66 matching lines @@
 {
   BYTE *ptr;
   UINT32 len;
   TPM_PCR_SELECTION pcrSelection;
   /* unmarshal input */
   ptr = req->param;
   len = req->paramSize;
   if (tpm_unmarshal_TPM_PCR_SELECTION(&ptr, &len, &pcrSelection)
       || len != 0) return TPM_BAD_PARAMETER;
   /* execute command */
+#ifdef MTM_EMULATOR
+  return MTM_PCR_Reset(&pcrSelection);
+#else
   return TPM_PCR_Reset(&pcrSelection);
+#endif
 }
 
 static TPM_RESULT execute_TPM_Quote2(TPM_REQUEST *req, TPM_RESPONSE *rsp)
 {
   BYTE *ptr;
   UINT32 len;
   TPM_KEY_HANDLE keyHandle;
   TPM_NONCE externalData;
   TPM_PCR_SELECTION targetPCR;
   BOOL addVersion;
@@ skipping 644 matching lines @@
   UINT32 len;
   TPM_HANDLE handle;
   TPM_RESOURCE_TYPE resourceType;
   /* unmarshal input */
   ptr = req->param;
   len = req->paramSize;
   if (tpm_unmarshal_TPM_HANDLE(&ptr, &len, &handle)
       || tpm_unmarshal_TPM_RESOURCE_TYPE(&ptr, &len, &resourceType)
       || len != 0) return TPM_BAD_PARAMETER;
   /* execute command */
+#ifdef MTM_EMULATOR
+  return MTM_FlushSpecific(handle, resourceType);
+#else
   return TPM_FlushSpecific(handle, resourceType);
+#endif
 }
 
 static TPM_RESULT execute_TPM_GetTicks(TPM_REQUEST *req, TPM_RESPONSE *rsp)
 {
   BYTE *ptr;
   UINT32 len;
   TPM_CURRENT_TICKS currentTime;
   TPM_RESULT res;
   /* execute command */
   res = TPM_GetTicks(&currentTime);
@@ skipping 256 matching lines @@
   UINT32 len;
   TPM_COUNT_ID countID;
   /* compute parameter digest */
   tpm_compute_in_param_digest(req);
   /* unmarshal input */
   ptr = req->param;
   len = req->paramSize;
   if (tpm_unmarshal_TPM_COUNT_ID(&ptr, &len, &countID)
       || len != 0) return TPM_BAD_PARAMETER;
   /* execute command */
+#ifdef MTM_EMULATOR
+  return MTM_ReleaseCounter(countID, &req->auth1);
+#else
   return TPM_ReleaseCounter(countID, &req->auth1);
+#endif
 }
 
 static TPM_RESULT execute_TPM_ReleaseCounterOwner(TPM_REQUEST *req, TPM_RESPONSE *rsp)
 {
   BYTE *ptr;
   UINT32 len;
   TPM_COUNT_ID countID;
   /* compute parameter digest */
   tpm_compute_in_param_digest(req);
   /* unmarshal input */
   ptr = req->param;
   len = req->paramSize;
   if (tpm_unmarshal_TPM_COUNT_ID(&ptr, &len, &countID)
       || len != 0) return TPM_BAD_PARAMETER;
   /* execute command */
+#ifdef MTM_EMULATOR
+  return MTM_ReleaseCounterOwner(countID, &req->auth1);
+#else
   return TPM_ReleaseCounterOwner(countID, &req->auth1);
+#endif
 }
 
 static TPM_RESULT execute_TPM_DAA_Join(TPM_REQUEST *req, TPM_RESPONSE *rsp)
 {
   BYTE *ptr;
   UINT32 len;
   TPM_HANDLE handle;
   BYTE stage;
   UINT32 inputSize0;
   BYTE *inputData0;
@@ skipping 1128 matching lines @@
       debug("[TPM_ORD_Reset]");
       res = execute_TPM_Reset(req, rsp);
     break;
 
     case TPM_ORD_OwnerReadPubek:
       debug("[TPM_ORD_OwnerReadPubek]");
       res = execute_TPM_OwnerReadPubek(req, rsp);
     break;
 
     default:
+#ifdef MTM_EMULATOR
+      res = mtm_execute_command(req, rsp);
+      if (res != TPM_BAD_ORDINAL) break;
+#endif
       info("The ordinal (0x%02x) was unknown or inconsistent", req->ordinal);
       tpm_setup_error_response(TPM_BAD_ORDINAL, rsp);
       return;
   }
 
   /* setup response */
   if (res != TPM_SUCCESS) {
     info("TPM command failed: (0x%02x) %s", res, tpm_error_to_string(res));
     tpm_setup_error_response(res, rsp);
     if (!(res & TPM_NON_FATAL)) {
       if (rsp->auth1 != NULL) rsp->auth1->continueAuthSession = FALSE;
       if (rsp->auth2 != NULL) rsp->auth2->continueAuthSession = FALSE;
     }
   } else {
     info("TPM command succeeded");
     rsp->size += rsp->paramSize;
     if (rsp->tag != TPM_TAG_RSP_COMMAND) tpm_setup_rsp_auth(req->ordinal, rsp);
-#ifdef TPM_STRONG_PERSISTENCE
-    if (tpm_store_permanent_data() != 0) {
-      error("tpm_store_permanent_data() failed");
-    } 
-#endif
+    if (tpmConf & TPM_CONF_STRONG_PERSISTENCE) {
+      if (tpm_store_permanent_data() != 0) {
+        error("tpm_store_permanent_data() failed");
+      }
+    }
   }
   /* terminate authorization sessions if necessary */
   if (rsp->auth1 != NULL && !rsp->auth1->continueAuthSession) 
     TPM_FlushSpecific(rsp->auth1->authHandle, HANDLE_TO_RT(rsp->auth1->authHandle));
   if (rsp->auth2 != NULL && !rsp->auth2->continueAuthSession) 
     TPM_FlushSpecific(rsp->auth2->authHandle, TPM_RT_AUTH);
   /* if transportExclusive is set, only the execution of TPM_ExecuteTransport
      and TPM_ReleaseTransportSigned is allowed */
   if (tpmData.stany.flags.transportExclusive
       && req->ordinal != TPM_ORD_ExecuteTransport
       && req->ordinal != TPM_ORD_ReleaseTransportSigned) {
     TPM_FlushSpecific(tpmData.stany.data.transExclusive, TPM_RT_TRANS);
     tpmData.stany.flags.transportExclusive = FALSE;
   }
 }
 
-void tpm_emulator_init(uint32_t startup)
+void tpm_emulator_init(uint32_t startup, uint32_t conf)
 {
-  debug("tpm_emulator_init()");
+  debug("tpm_emulator_init(%d, 0x%08x)", startup, conf);
+  tpmConf = conf;
+#ifdef MTM_EMULATOR
+  info("MTM support enabled");
+#endif
   /* try to restore data, if it fails use default values */
   if (tpm_restore_permanent_data() != 0) tpm_init_data();
   TPM_Init(startup);
 }
 
 void tpm_emulator_shutdown()
 {
   debug("tpm_emulator_shutdown()");
   if (TPM_SaveState() != TPM_SUCCESS) {
     error("TPM_SaveState() failed");
@@ skipping 52 matching lines @@
   if (tpm_marshal_TPM_RESPONSE(&ptr, &len, &rsp) != 0) {
     error("tpm_marshal_TPM_RESPONSE() failed");
     if (free_out) tpm_free(*out);
     tpm_free(rsp.param);
     return -1;
   }
   tpm_free(rsp.param);
   return 0;
 }