Chinaunix首页 | 论坛 | 博客

止觞zhangwei.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

止觞

  • 博客访问： 270502
  • 博文数量： 18
  • 博客积分： 787
  • 博客等级： 军士长
  • 技术积分： 235
  • 用 户 组： 普通用户
  • 注册时间： 2010-04-27 21:20
文章分类

全部博文（18）

文章存档

2015年（2）

2013年（2）

2012年（7）

2011年（1）

2010年（6）

我的朋友
最近访客
推荐博文
相关博文
TPM笔记（3) -- TPM实例

分类： LINUX

2012-02-16 14:39:52

最近更新时间：2012/6/14 10：24

参考书籍《可信计算》（A Practical Guide of Trusted Computing, 机械工业出版社）。
详细讲解书中 第八章--使用TPM密钥 的示例，因为openssl的开发库变动，所以使用不同的openssl API不保证成功，书中代码有一些不能直接调试通过，我对无法通过的部分做了改动，下面部分经测试无误，但仍然不完整，仅进行到创建AIK这一步，创建AIK的过程可能会另开一篇博文。
另需要注意的是，由于我的openssl-tpm-engine无法安装成功，所以关于openssl我使用了一些内嵌的函数实现，而非直接使用openssl-tpm-engine的API，下面是代码部分：

MyFunc_KeyHierarchy.c：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <errno.h>
  4. #include <tss/platform.h>
  5. #include <tss/tss_typedef.h>
  6. #include <tss/tss_structs.h>
  7. #include <tss/tss_defines.h>
  8. #include <tss/tspi.h>
  9. #include <openssl/rsa.h>
  10. #include <openssl/err.h>
  11. #include <openssl/ssl.h>


  14. //下面三个参数在书中都没有定义，此处为我本人主动定义
  15. #define ENTROPY_SIZE 10
  16. #define MAX_PASS_LEN 4097
  17. #define RANDOM_DEVICE "/dev/random"
  18. #define SOFTWARE_KEY_FILE_PATH "/home/darcy/exercise/TPM/test.key"
  19. #define CA_KEY_FILE_PATH "/home/darcy/exercise/TPM/test1.key"

  21. TSS_HCONTEXT hContext;
  22. TSS_HKEY hSRK;
  23. TSS_HTPM hTPM;

  25. //获取错误信息，工具函数
  26. const char *get_error(TSS_RESULT res)
  27. {
  28.     switch(ERROR_CODE(res))
  29.     {
  30.         case 0x0001L:
  31.             return "Authentication failed";
  32.         case TSS_SUCCESS:
  33.             return "success";
  34.         case TSS_E_INVALID_HANDLE:
  35.             return "hContext or phObject is an invalid handle";
  36.         case TSS_E_BAD_PARAMETER:
  37.             return "persistent storage type is not valid/One or more parameters is incorrect";
  38.         case TSS_E_INTERNAL_ERROR:
  39.             return "an error occurred internal to the TSS";
  40.         case TSS_E_PS_KEY_NOTFOUND:
  41.             return "NOT FOUND SRK";
  42.         case TSS_E_INVALID_ATTRIB_FLAG:
  43.             return "attrib flag is incorrect";
  44.         case TSS_E_INVALID_ATTRIB_SUBFLAG:
  45.             return "subflag is incorrect";
  46.         case TSS_E_INVALID_ATTRIB_DATA:
  47.             return "ulAttrib is incorrect";
  48.         case TSS_E_KEY_ALREADY_REGISTERED:
  49.             return "UUID used";
  50.         case TSS_E_KEY_NOT_LOADED:
  51.             return "the addressed key is currently not loaded";
  52.         default:
  53.             return "unknown error";
  54.     }
  55. }

  57. //判断操作是否成功
  58. void
  59. Assert(TSS_RESULT result, char *functionName)
  60. {
  61.     if(result != TSS_SUCCESS)
  62.     {
  63.         printf("%s Error: %s\n", functionName, get_error(result));
  64.         exit(1);
  65.     }
  66. }

  68. //计算size，返回密钥大小
  69. TSS_FLAG
  70. get_tss_key_size(UINT32 size)
  71. {
  72.     if(size <= 512){
  73.         return TSS_KEY_SIZE_512;
  74.     }else if(size <= 1024){
  75.         return TSS_KEY_SIZE_1024;
  76.     }else if(size <= 2048){
  77.         return TSS_KEY_SIZE_2048;
  78.     }else if(size <= 4096){
  79.         return TSS_KEY_SIZE_4096;
  80.     }else if(size <= 8192){
  81.         return TSS_KEY_SIZE_8192;
  82.     }else if(size <= 16384){
  83.         return TSS_KEY_SIZE_16384;
  84.     }

  86.     return TSS_KEY_SIZE_2048;
  87. }

  89. void
  90. openssl_print_errors()
  91. {
  92.     ERR_load_ERR_strings();
  93.     ERR_load_crypto_strings();
  94.     ERR_print_errors_fp(stderr);
  95. }

  97. RSA *
  98. openssl_read_key(char *filename)
  99. {
  100.         BIO *b = NULL;
  101.         RSA *rsa = NULL;

  103.         b = BIO_new_file(filename, "r");
  104.         if (b == NULL) {
  105.                 fprintf(stderr, "Error opening file for read: %s\n", filename);
  106.                 return NULL;
  107.         }

  109.         if ((rsa = PEM_read_bio_RSAPrivateKey(b, NULL, 0, NULL)) == NULL) {
  110.                 fprintf(stderr, "Reading key %s from disk failed.\n", filename);
  111.                 openssl_print_errors();
  112.         }
  113.         BIO_free(b);

  115.         return rsa;
  116. }

  118. int
  119. openssl_get_modulus_and_prime(RSA *rsa, unsigned int *size_n, unsigned char *n,
  120.                   unsigned int *size_p, unsigned char *p)
  121. {
  122.     /* get the modulus from the RSA object */
  123.     if ((*size_n = BN_bn2bin(rsa->n, n)) <= 0) {
  124.         openssl_print_errors();
  125.         return -1;
  126.     }
  127.     /* get one of the primes from the RSA object */
  128.     if ((*size_p = BN_bn2bin(rsa->p, p)) <= 0) {
  129.         openssl_print_errors();
  130.         return -1;
  131.     }

  133.     return 0;
  134. }

  136. //获取系统随机数函数
  137. TSS_RESULT
  138. MyFunc_GetRandom(UINT32 size, BYTE *data)
  139. {
  140.     FILE *f = NULL;
  141.     f = fopen(RANDOM_DEVICE, "r");
  142.     if (f == NULL) {
  143.         //书中采用了LogError函数，此处我直接使用printf
  144.         printf("open of %s failed: %s", RANDOM_DEVICE,
  145.         strerror(errno));
  146.         return TSS_E_INTERNAL_ERROR;
  147.     }
  148.     if (fread(data, size, 1, f) == 0) {
  149.         printf("fread of %s failed: %s", RANDOM_DEVICE,
  150.         strerror(errno));
  151.         fclose(f);
  152.         return TSS_E_INTERNAL_ERROR;
  153.     }
  154.     fclose(f);
  155.     return TSS_SUCCESS;
  156. }

  158. TSS_RESULT
  159. MyFunc_CreateTPMKey(TSS_HKEY hParentKey,
  160.                     TSS_FLAG initFlags,
  161.                     TSS_HPCRS hPcrs,
  162.                     TSS_HKEY *hKey)
  163. {
  164.     TSS_RESULT result;
  165.     TSS_HPOLICY hPolicy;
  166.     char *secret = "test";
  167.     /* create the key object */
  168.     result = Tspi_Context_CreateObject(hContext,TSS_OBJECT_TYPE_RSAKEY,
  169.                                         initFlags, hKey);
  170.     if (result) {
  171.         printf("Tspi_Context_CreateObject failed: %s\n",
  172.                 get_error(result));
  173.         return result;
  174.     }
  175.     /* Get the policy object, implicitly created when we created the
  176.      * key object */
  177.     result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_POLICY,TSS_POLICY_USAGE, &hPolicy);
  178.     if (result) {
  179.         printf("Tspi_GetPolicyObject failed: %s\n", get_error(result));
  180.         Tspi_Context_CloseObject(hContext, *hKey);
  181.         return result;
  182.     }
  183.     /* If we’re creating this key with no password, set the secret
  184.     * mode so that the popup will be supressed */
  185.     if (!(initFlags & TSS_KEY_AUTHORIZATION)) {
  186.         result = Tspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_NONE,
  187.                                         0, NULL);
  188.         if(result)
  189.         {
  190.             printf("Tspi_Policy_SetSecret error: %s\n", get_error(result));
  191.         }
  192.     }
  193.     /* Make the call to the TPM to create the key */
  194.     result = Tspi_Key_CreateKey(*hKey, hParentKey, hPcrs);
  195.     if (result) {
  196.         printf("Tspi_Key_CreateKey failed: %s\n", get_error(result));
  197.         Tspi_Context_CloseObject(hContext, *hKey);
  198.         return result;
  199.     }
  200.     
  201.     if(result == TSS_SUCCESS)
  202.     {
  203.         printf("Create TPM key succeed!\n");
  204.     }

  206.     return TSS_SUCCESS;
  207. }


  210. TSS_RESULT
  211. MyFunc_WrapKey(char *path,
  212.                 TSS_HKEY hParentKey,
  213.                 TSS_FLAG initFlags,
  214.                 TSS_HPCRS hPcrs,
  215.                 TSS_HKEY *hKey)
  216. {

  218.     RSA *rsa;
  219.     UINT32 pubKeyLen;
  220.     BYTE *pubKey;
  221.     TSS_RESULT result;
  222.     unsigned char n[2048], p[2048];
  223.     int sizeN, sizeP;
  224.     UINT32 keySize;
  225.     TSS_HPOLICY keyMigPolicy;
  226.     /* Read in the plaintext key from disk. */
  227.     if ((rsa = openssl_read_key(path)) == NULL) {
  228.         printf("Failed opening OpenSSL key file!\n");
  229.         return TSS_E_FAIL;
  230.     }

  232.     /* Pull the SRK’s pub key into the hSRK object. Note that this is
  233.     * not necessary for any key but the SRK. The SRK’s pub key is not
  234.     * stored in system persistent storage as other keys are. This
  235.     * protects it from being loaded by unauthorized users who could
  236.     * then use it to identify the machine from across the Internet. */
  237.     //result = Tspi_Key_GetPubKey(hSRK, &pubKeyLen, &pubKey);
  238.     result = Tspi_TPM_OwnerGetSRKPubKey(hTPM, &pubKeyLen, &pubKey);
  239.     if (result != TSS_SUCCESS) {
  240.         printf("Tspi_Key_GetPubKey failed: %s\n", get_error(result));
  241.         RSA_free(rsa);
  242.         printf("Error code:%d!\n", result);
  243.         return result;
  244.     }
  245.     /* Free here since the pubKey data is stored internally to the
  246.     * hSRK object in addition to being returned above */
  247.     //Tspi_Context_FreeMemory(hContext, pubKey);
  248.     /* convert the OpenSSL key’s size in bits to a TSS key size flag
  249.     * suitable for including in initFlags. */
  250.     if ((keySize = get_tss_key_size(RSA_size(rsa) * 8)) == 0){
  251.         return TSS_E_BAD_PARAMETER;
  252.     }
  253.     /* create the TSS key object */
  254.     /*TSS_FLAG tempFlag = TSS_KEY_SIZE_2048|
  255.                               TSS_KEY_TYPE_STORAGE|
  256.                               TSS_KEY_AUTHORIZATION;*/
  257.     result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY,
  258.                                         keySize|initFlags, hKey);

  260.     if (result != TSS_SUCCESS) {
  261.         printf("Tspi_Context_CreateObject failed: %s\n",
  262.                 get_error(result));
  263.         return result;
  264.     }
  265.     /*if This function handles the OpenSSL calls to extract the public N
  266.     * and private P, parts of the software RSA key. Both of these
  267.     * components will be put into the wrapped TSS key object. */
  268.     if(openssl_get_modulus_and_prime(rsa, &sizeN, n, &sizeP, p) != 0) {
  269.         Tspi_Context_CloseObject(hContext, *hKey);
  270.         *hKey = 0;
  271.         return result;
  272.     }
  273.     /* set the public key data in the TSS object */
  274.     result = Tspi_SetAttribData(*hKey, TSS_TSPATTRIB_RSAKEY_INFO,
  275.                                 TSS_TSPATTRIB_KEYINFO_RSA_MODULUS,
  276.                                 sizeN, n);
  277.     if (result != TSS_SUCCESS) {
  278.         printf("Tspi_SetAttribData failed: %s; Error number:%.2x\n", get_error(result),result);
  279.         Tspi_Context_CloseObject(hContext, *hKey);
  280.         *hKey = 0;
  281.         return result;
  282.     }
  283.     /* set the private key data in the TSS object */
  284.     result = Tspi_SetAttribData(*hKey, TSS_TSPATTRIB_KEY_BLOB,
  285.                                 TSS_TSPATTRIB_KEYBLOB_PRIVATE_KEY,
  286.                                 sizeP, p);
  287.     if (result != TSS_SUCCESS) {
  288.         printf("Tspi_SetAttribData failed: %s\n", get_error(result));
  289.         Tspi_Context_CloseObject(hContext, *hKey);
  290.         *hKey = 0;
  291.         return result;
  292.     }
  293.     
  294.     result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_POLICY, TSS_POLICY_MIGRATION, &keyMigPolicy);
  295.     Assert(result, "Tspi_GetPolicyObject");
  296.     BYTE wellKnownSecret[] = TSS_WELL_KNOWN_SECRET;
  297.     result = Tspi_Policy_SetSecret(keyMigPolicy,TSS_SECRET_MODE_SHA1,
  298.                                     20, wellKnownSecret);
  299.     Assert(result, "Tspi_Policy_SetSecret");
  300.     result = Tspi_Policy_AssignToObject(keyMigPolicy, *hKey);
  301.     Assert(result, "Tspi_Policy_AssignToObject");

  303.     /* Call the TSS to do the key wrapping */
  304.     result = Tspi_Key_WrapKey(*hKey, hParentKey, hPcrs);
  305.     //result = Tspi_Key_CreateKey(*hKey, hParentKey, 0);
  306.     if (result != TSS_SUCCESS) {
  307.         printf("Tspi_Key_WrapKey failed: %s; Error number:%.2x\n", get_error(result), result);
  308.         Tspi_Context_CloseObject(hContext, *hKey);
  309.         *hKey = 0;
  310.     }
  311.     RSA_free(rsa);

  313.     if(result ==TSS_SUCCESS)
  314.     {
  315.         printf("Wrap key succeed!\n");
  316.     }

  318.     return result;
  319. }

  321. /*create the key hierarchy*/
  322. int MyFunc_CreateKeyHierarchy()
  323. {
  324.     //TSS_HCONTEXT hContext;
  325.     //TSS_HTPM hTPM;
  326.     TSS_HPOLICY hSRKPolicy, hTpmPolicy;
  327.     BYTE entropyData[ENTROPY_SIZE];
  328.     BYTE secretData[] = TSS_WELL_KNOWN_SECRET;
  329.     int secretDataLen = TCPA_SHA1_160_HASH_LEN;
  330.     BYTE tpmPasswd[] = "helloworld";
  331.     int tpmPasswdLen = strlen(tpmPasswd);
  332.     BYTE srkPasswd[] = "helloworld";
  333.     //char *secretData = "helloworld";
  334.     TSS_FLAG initFlags;
  335.     TSS_UUID swMigKeyUuid, systemMigKeyUuid;
  336.     TSS_HKEY hUserSWMigKey, hSystemMigKey, hKeyPcrs;
  337.     TSS_HKEY hMigKeyBind, hSealingKey, hMAKey;
  338.     TSS_HKEY hAIKey, hMtncKey;
  339.     TSS_HPOLICY hUserSWMigKeyPolicy;
  340.     TSS_HPCRS hPcrs;
  341.     UINT32 pcrLen;
  342.     BYTE *pcrValue;
  343.     TSS_RESULT result;
  344.     TSS_BOOL tpmState;
  345.     BYTE userPass[MAX_PASS_LEN];
  346.     BYTE *random;
  347.     UINT32 aik_label_len, credSize;
  348.     BYTE *aik_label, *cred;
  349.     TSS_UUID AIKUuid;
  350.     TSS_VALIDATION validationData;
  351.     BYTE *ticket;
  352.     UINT32 ticketLen;

  354.     BYTE *mtncBlob, *migBlob;
  355.     UINT32 mtncBlobLen, migBlobLen;
  356.     int i; //loop index
  357.     TSS_UUID SRK_UUID = TSS_UUID_SRK;

  359.     /* OpenSSL objects */
  360.     RSA *ca_rsa, *migration_pub_rsa, *maintenance_pub_rsa;

  362.     /* Make any necessary setup calls to OpenSSL */
  363.     //init_external_libraries();
  364.     /* SSL init*/

  366.     //书中使用的init_external_libraries找不到函数，用别的方式代替
  367.     SSL_library_init();
  368.     /* load all SSL */
  369.     OpenSSL_add_all_algorithms();
  370.     /* load all SSL error message */
  371.     SSL_load_error_strings();

  373.     Tspi_Context_Create(&hContext);
  374.     Tspi_Context_Connect(hContext, NULL);
  375.     result = Tspi_Context_GetTpmObject(hContext, &hTPM);
  376.     if(result != TSS_SUCCESS)
  377.     {
  378.         printf("Tspi_Context_GetTpmObject Error: %s\n", get_error(result));
  379.         exit(1);
  380.     }

  382.     /* Add entropy to the TPM’s random number generator from the
  383.     * system’s random device */
  384.     MyFunc_GetRandom(ENTROPY_SIZE, entropyData);
  385.     Tspi_TPM_StirRandom(hTPM, ENTROPY_SIZE, entropyData);
  386.     printf("Random number:");
  387.     for(i=0; i<ENTROPY_SIZE; i++)
  388.     {
  389.         printf("%.2x ", entropyData[i]);
  390.     }
  391.     printf("\n");

  393.     /* Load the SRK from storage in the System Persistent Store */
  394.     result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, SRK_UUID,
  395.                                         &hSRK);
  396.     Assert(result, "Tspi_Context_LoadKeyByUUID");

  398.     /*get the tpm policy to take the tpm ownership*/
  399.     result = Tspi_GetPolicyObject(hTPM, TSS_POLICY_USAGE, &hTpmPolicy);
  400.     Assert(result, "Tspi_GetPolicyObject for TPM");
  401.     result = Tspi_Policy_SetSecret(hTpmPolicy, TSS_SECRET_MODE_PLAIN,
  402.                                     tpmPasswdLen, tpmPasswd);
  403.     Assert(result, "Tspi_Policy_SetSecret");
  404.     /* Set the SRK’s password since it will be referenced below */
  405.     //changed by zw
  406.     //hContext做第一个参数的时候，始终报错TSS_E_BAD_PARAMETER,所以替换成hSRK
  407.     result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &hSRKPolicy);
  408.     Assert(result, "Tspi_GetPolicyObject");

  410.     result = Tspi_Policy_SetSecret(hSRKPolicy, TSS_SECRET_MODE_PLAIN,
  411.                                      strlen(srkPasswd), srkPasswd);
  412.     //同样，因为我的机器上SRK没有设置密码认证，所有密钥模式为TSS_SECRET_MODE_NONE
  413.     //result = Tspi_Policy_SetSecret(hSRKPolicy, TSS_SECRET_MODE_NONE,
  414.     //                                0, NULL);
  415.     Assert(result, "Tspi_Policy_SetSecret");

  417.     /*take ownership*/
  418.     //result = Tspi_TPM_TakeOwnership(hTPM, hSRK, 0);
  419.     //Assert(result, "Tspi_TPM_TakeOwnership");

  421.     /* Wrap the software generated key with the SRK’s public key.
  422.     * initFlags is set to make this key a migratable storage key
  423.     * that requires a password. */
  424.     initFlags = TSS_KEY_TYPE_STORAGE | TSS_KEY_MIGRATABLE |
  425.                     TSS_KEY_AUTHORIZATION;
  426.     
  427.     MyFunc_WrapKey(SOFTWARE_KEY_FILE_PATH, hSRK, initFlags, 0,
  428.                  &hUserSWMigKey);
  429.     
  430.     /* Register the wrapped key in user persistent storage */
  431.     result = Tspi_Context_RegisterKey(hContext, hUserSWMigKey,
  432.                                     TSS_PS_TYPE_USER, swMigKeyUuid,
  433.                                     TSS_PS_TYPE_SYSTEM, SRK_UUID);
  434.     Assert(result, "Tspi_Context_RegisterKey");
  435.     
  436.     result = Tspi_GetPolicyObject(hUserSWMigKey, TSS_POLICY_USAGE,
  437.                                     &hUserSWMigKeyPolicy);
  438.     Assert(result, "Tspi_GetPolicyObject");

  440.     sprintf(userPass, "helloworld");
  441.     Tspi_Policy_SetSecret(hUserSWMigKeyPolicy, TSS_SECRET_MODE_PLAIN,
  442.                             strlen(userPass), userPass);

  444.     /* Zero-out the password entered, keeping it in memory for the
  445.      * smallest amount of time possible */

  447.     memset(userPass, 0, MAX_PASS_LEN);
  448.     /* create a non-migratable signing key not bound to any PCRs */
  449.     initFlags = TSS_KEY_TYPE_SIGNING | TSS_KEY_SIZE_2048 |
  450.                 TSS_KEY_NOT_MIGRATABLE;
  451.     /* Pass ‘0’ as the handle to the PCRs object, to keep the TSS from
  452.     * binding this key to any PCRs */
  453.     MyFunc_CreateTPMKey(hSRK, initFlags, 0, &hSystemMigKey);
  454.     /* Register the key in system persistent storage */
  455.     Tspi_Context_RegisterKey(hContext, hSystemMigKey, TSS_PS_TYPE_SYSTEM,
  456.                             systemMigKeyUuid, TSS_PS_TYPE_SYSTEM,
  457.                             SRK_UUID);
  458.     /* Create a PCR composite object with the current values of PCRs
  459.     * 4 and 5 */
  460.     Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_PCRS, 0, &hPcrs);
  461.     Tspi_TPM_PcrRead(hTPM, 4, &pcrLen, &pcrValue);
  462.     Tspi_PcrComposite_SetPcrValue(hPcrs, 4, pcrLen, pcrValue);
  463.     /* Free the pcrValue data returned from the Tspi_TPM_PcrRead()
  464.     * function. At this point, the value of the PCR register has been
  465.     * copied into the PCR object hPcrs by the TSS. */
  466.     Tspi_Context_FreeMemory(hContext, pcrValue);
  467.     Tspi_TPM_PcrRead(hTPM, 5, &pcrLen, &pcrValue);
  468.     Tspi_PcrComposite_SetPcrValue(hPcrs, 5, pcrLen, pcrValue);
  469.     Tspi_Context_FreeMemory(hContext, pcrValue);

  471.     /* Create a non-migratable signing key bound to PCRs 4 and 5 */
  472.     initFlags = TSS_KEY_TYPE_SIGNING | TSS_KEY_SIZE_2048 |
  473.     TSS_KEY_NOT_MIGRATABLE;
  474.     /*
  475.     *Passing the hPcrs handle here ensures the new key is bound to
  476.     *PCRs 4 and 5. If the value of those PCRs changes, the key will
  477.     *become unusable until a platform reset can return them to their
  478.     *present state */
  479.     MyFunc_CreateTPMKey(hSRK, initFlags, hPcrs, &hKeyPcrs);

  481.     /* Read in the Privacy CA’s key from disk */
  482.     ca_rsa = openssl_read_key(CA_KEY_FILE_PATH);
  483.     aik_label = "My Identity Label";
  484.     aik_label_len = strlen(aik_label) + 1;

  486.     /*Create AIK*/
  487.     /*MyFunc_CreateAIK(ca_rsa, aik_label, aik_label_len, &hAIKey,
  488.                     &credSize, cred);
  489.     */
  490.     return 0;
  491. }

  493. int main(void)
  494. {
  495.     MyFunc_CreateKeyHierarchy();

  497.     return 0;
  498. }
编译方法：
gcc -g -o MyFunc_KeyHierarchy MyFunc_KeyHierarchy.c -ltspi -lcrypto -lssl

(未完待续...)



阅读(8140) | 评论(1) | 转发(0) |
0

上一篇：TPM笔记（2)--TPM安装手册

下一篇：TPM笔记（4) -- 出错说明及解决办法

给主人留下些什么吧！~~

xuxin2358916s2014-06-11 16:48:24

您好，最近在学习可信计算，我在linux下安装好了Trousers和tpm-tools，可是在执行tpm_version时出现Tspi_Context_Connect Failed : 0x00002004 lay=tcs code=00004 Internal software error的错误，请问该如何解决，谢谢。

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6