文档章节

tpm迁移密钥

 宋小八
发布于 2017/09/29 18:09
字数 2635
阅读 123
收藏 2

说明:代码分为源tpm(服务端)和目的TPM(客户端),传输数据时使用socket编程实现通信。

源tpm端key.c源码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <tss/tss_error.h>
#include <tss/platform.h>
#include <tss/tss_defines.h>
#include <tss/tss_typedef.h>
#include <tss/tss_structs.h>
#include <tss/tspi.h>
#include <trousers/trousers.h>

#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/ssl.h>

#include<netinet/in.h> // sockaddr_in
#include<sys/types.h>  // socket
#include<sys/socket.h> // socket
#include<stdio.h>    // printf
#include<stdlib.h>   // exit
#include<string.h>   // bzero

#define SOFTWARE_KEY_FILE_PATH "/home/sm/opensslkey/key.pem"
#define MIMRATION_KEY_FILE_PATH "/home/sm/opensslkey/migkey.pem"
#define Debug(message, tResult) printf("%s : %s\n", message, (char *)Trspi_Error_String(result))

#define SERVER_PORT 8000
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512

TSS_HCONTEXT    hContext;
TSS_HTPM        hTPM;
TSS_HKEY        hSRK;
//获取错误信息,工具函数
const char *get_error(TSS_RESULT res)
{
    switch(ERROR_CODE(res))
    {
        case 0x0001L:
            return "Authentication failed";
        case TSS_SUCCESS:
            return "success";
        case TSS_E_INVALID_HANDLE:
            return "hContext or phObject is an invalid handle";
        case TSS_E_BAD_PARAMETER:
            return "persistent storage type is not valid/One or more parameters is incorrect";
        case TSS_E_INTERNAL_ERROR:
            return "an error occurred internal to the TSS";
        case TSS_E_PS_KEY_NOTFOUND:
            return "NOT FOUND SRK";
        case TSS_E_INVALID_ATTRIB_FLAG:
            return "attrib flag is incorrect";
        case TSS_E_INVALID_ATTRIB_SUBFLAG:
            return "subflag is incorrect";
        case TSS_E_INVALID_ATTRIB_DATA:
            return "ulAttrib is incorrect";
        case TSS_E_KEY_ALREADY_REGISTERED:
            return "UUID used";
        case TSS_E_KEY_NOT_LOADED:
            return "the addressed key is currently not loaded";
        default:
            return "unknown error";
    }
}

void
openssl_print_errors()
{
    ERR_load_ERR_strings();
    ERR_load_crypto_strings();
    ERR_print_errors_fp(stderr);
}

RSA *
openssl_read_key(char *filename)
{
        BIO *b = NULL;
        RSA *rsa = NULL;

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

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

        return rsa;
}
//计算size,返回密钥大小
TSS_FLAG
get_tss_key_size(UINT32 size)
{
    if(size <= 512){
        return TSS_KEY_SIZE_512;
    }else if(size <= 1024){
        return TSS_KEY_SIZE_1024;
    }else if(size <= 2048){
        return TSS_KEY_SIZE_2048;
    }else if(size <= 4096){
        return TSS_KEY_SIZE_4096;
    }else if(size <= 8192){
        return TSS_KEY_SIZE_8192;
    }else if(size <= 16384){
        return TSS_KEY_SIZE_16384;
    }

    return TSS_KEY_SIZE_2048;
}
int
openssl_get_modulus_and_prime(RSA *rsa, unsigned int *size_n, unsigned char *n,
                  unsigned int *size_p, unsigned char *p)
{
    /* 从RSA对象获取modulus */
    if ((*size_n = BN_bn2bin(rsa->n, n)) <= 0) {
        openssl_print_errors();
        return -1;
    }
    /* 从RSA对象获取 primes */
    if ((*size_p = BN_bn2bin(rsa->p, p)) <= 0) {
        openssl_print_errors();
        return -1;
    }

    return 0;
}
TSS_RESULT
MyFunc_WrapKey(char *path,
                TSS_HKEY hParentKey,
                TSS_FLAG initFlags,
                TSS_HPCRS hPcrs,
                TSS_HKEY *hKey)
{

    RSA             *rsa;
    UINT32          pubKeyLen;
    BYTE            *pubKey;
    TSS_RESULT      result;
    unsigned char   n[2048], p[2048];
    int             sizeN, sizeP;
    UINT32          keySize;
    TSS_HPOLICY     keyMigPolicy;
    BYTE            wellKnownSecret[] = TSS_WELL_KNOWN_SECRET;
    /*从磁盘读取openssl 密钥. */
    if ((rsa = openssl_read_key(path)) == NULL) {
        printf("Failed opening OpenSSL key file!\n");
        return TSS_E_FAIL;
    }

    /*获取SRK的公钥*/
    //result = Tspi_Key_GetPubKey(hSRK, &pubKeyLen, &pubKey);
    result = Tspi_TPM_OwnerGetSRKPubKey(hTPM, &pubKeyLen, &pubKey);
    if (result != TSS_SUCCESS) {
        printf("Tspi_Key_GetPubKey failed: %s\n", get_error(result));
        RSA_free(rsa);
        printf("Error code:%d!\n", result);
        return result;
    }
    /* 将openSSL密钥转换为适合包含于initFlags的TSS密钥大小标记. */
    if ((keySize = get_tss_key_size(RSA_size(rsa) * 8)) == 0){
        return TSS_E_BAD_PARAMETER;
    }
    /*创建TSS 密钥对象 */
    result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY,keySize|initFlags, hKey);
    Debug("create tss key object :", result);
    if (result != TSS_SUCCESS) {
        printf("Tspi_Context_CreateObject failed: %s\n",get_error(result));
        return result;
    }
    /*使用openSSL调用提取RSA软件密钥中心公开的N和私有的P */
    if(openssl_get_modulus_and_prime(rsa, &sizeN, n, &sizeP, p) != 0) {
        Tspi_Context_CloseObject(hContext, *hKey);
        *hKey = 0;
        return result;
    }
    /* 设置密钥对象的公钥数据 */
    result = Tspi_SetAttribData(*hKey, TSS_TSPATTRIB_RSAKEY_INFO,
                                TSS_TSPATTRIB_KEYINFO_RSA_MODULUS,
                                sizeN, n);
    Debug("set key object public:", result);
    if (result != TSS_SUCCESS) {
        printf("Tspi_SetAttribData failed: %s; Error number:%.2x\n", get_error(result),result);
        Tspi_Context_CloseObject(hContext, *hKey);
        *hKey = 0;
        return result;
    }
    /* 设置密钥对象的私钥数据*/
    result = Tspi_SetAttribData(*hKey, TSS_TSPATTRIB_KEY_BLOB,
                                TSS_TSPATTRIB_KEYBLOB_PRIVATE_KEY,
                                sizeP, p);
    Debug("set key object private:", result);
    if (result != TSS_SUCCESS) {
        printf("Tspi_SetAttribData failed: %s\n", get_error(result));
        Tspi_Context_CloseObject(hContext, *hKey);
        *hKey = 0;
        return result;
    }
    /* 设置密钥策略对象*/
    result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_POLICY, TSS_POLICY_MIGRATION, &keyMigPolicy);
    Debug("set key policy object :", result);
    /* 设置策略对象秘密细节*/
    result = Tspi_Policy_SetSecret(keyMigPolicy,TSS_SECRET_MODE_SHA1,20, wellKnownSecret);
    Debug("set key policy object secret:", result);
    /*为密钥分配策略 */
    result = Tspi_Policy_AssignToObject(keyMigPolicy, *hKey);
    Debug("assign policy object ro key  secret:", result);

    /*调用TSS接口封装密钥*/
    result = Tspi_Key_WrapKey(*hKey, hParentKey, hPcrs);
    Debug("Wrap Key:", result);
    if (result != TSS_SUCCESS) {
        printf("Tspi_Key_WrapKey failed: %s; Error number:%.2x\n", get_error(result), result);
        Tspi_Context_CloseObject(hContext, *hKey);
        *hKey = 0;
    }
    RSA_free(rsa);
    if(result ==TSS_SUCCESS)
    {
        printf("Wrap key succeed!\n");
    }

    return result;
}
TSS_RESULT
MyFunc_CreatePubKey(RSA *rsa,int padding,TSS_HKEY *hKey)
{
    TSS_RESULT      result;
    UINT32          encScheme,sizeN,keySize;
    BYTE            n[2048];

    switch (padding) {
        case RSA_PKCS1_PADDING:
        encScheme=TSS_ES_RSAESPKCSV15;
           break;
        case RSA_PKCS1_OAEP_PADDING:
                encScheme=TSS_ES_RSAESOAEP_SHA1_MGF1;
                break;
        case RSA_NO_PADDING:
                encScheme=TSS_ES_NONE;
                break;
        default:
                return  TSS_E_INTERNAL_ERROR;
                break;
    }
    keySize=get_tss_key_size(RSA_size(rsa)*8);
    if(keySize==0){
       return TSS_E_BAD_PARAMETER;
    }
    /*创建TSS密钥对象*/
    result=Tspi_Context_CreateObject(hContext,TSS_OBJECT_TYPE_RSAKEY,TSS_KEY_TYPE_LEGACY|keySize,hKey);
    Debug("create tss key object:",result);
    if(result!=TSS_SUCCESS){
        return result;
    }
    printf("111111111\n");
    /*从openSSL密钥获取公用'n'值*/
    if((sizeN=BN_bn2bin(rsa->n,n))<=0){
       printf("BN_bn2bin failed\n");
       ERR_print_errors_fp(stdout);
       Tspi_Context_CloseObject(hContext,*hKey);
       Debug("close context object:",result);
       return result;
    }
    printf("222222\n");
    /*在TSS对象中设置公钥数据*/
    //result=Tspi_SetAttribData(*hKey,TSS_TSPATTRIB_KEY_BLOB,TSS_TSPATTRIB_KEYBLOB_PUBLIC_KEY,sizeN,n);
 result = Tspi_SetAttribData(*hKey, TSS_TSPATTRIB_RSAKEY_INFO,TSS_TSPATTRIB_KEYINFO_RSA_MODULUS, sizeN, n);
    printf("333333\n");
    Debug("setAttrib public data:",result);
    if(result!=TSS_SUCCESS){
       printf("tspi_setattribdata faild\n");
       Tspi_Context_CloseObject(hContext,*hKey);
       Debug("close context object:",result);
       return result;

    }
    /*设置密钥算法*/
    result=Tspi_SetAttribUint32(*hKey,TSS_TSPATTRIB_KEY_INFO,TSS_TSPATTRIB_KEYINFO_ALGORITHM,TSS_ALG_RSA);
    Debug("set key algorithm:",result);
    if(result!=TSS_SUCCESS){
       printf("tspi_setattribunit32 faild\n");
       Tspi_Context_CloseObject(hContext,*hKey);
       Debug("close context object:",result);
       return result;
    }
    /*设置密钥的素数个数*/
    result=Tspi_SetAttribUint32(*hKey,TSS_TSPATTRIB_RSAKEY_INFO,TSS_TSPATTRIB_KEYINFO_RSA_PRIMES,2);
    Debug("set sushu geshu:",result);
    if(result!=TSS_SUCCESS){
       printf("tspi_setattribunit32 faild\n");
       Tspi_Context_CloseObject(hContext,*hKey);
       Debug("close context object:",result);
       return result;
    }
    /*设置密钥加密机制
    result=Tspi_SetAttribUint32(*hKey,TSS_TSPATTRIB_KEY_INFO,TSS_TSPATTRIB_KEYINFO_ENCSCHEME,encScheme);
    Debug("ser key enc :",result);
    if(result!=TSS_SUCCESS){
       printf("tspi_setattribunit32 faild\n");
       Tspi_Context_CloseObject(hContext,*hKey);
       Debug("close context object:",result);
       return result;
    }*/
    return TSS_SUCCESS;


}

int main(int argc, char **argv)
{
    
    TSS_HPCRS       hPcrs;
    TSS_HENCDATA    hEncData;
    TSS_HENCDATA    hRetrieveData;
    TSS_RESULT      result;
    TSS_HKEY        hUserSWMigKey,hMAKey;
    TSS_HPOLICY     hSRKPolicy,hPolicy,hownerpolicy;
    TSS_UUID        SRK_UUID = TSS_UUID_SRK,MigKeyUuid,swMigKeyUuid;
    BYTE            secretData[]=TSS_WELL_KNOWN_SECRET;
    TSS_FLAG        initFlags;
    BYTE            *ticket;
    BYTE            *migBlob;
    UINT32          ticketLen;
    UINT32          migBlobLen;
    char            file_name[512]="./tpm.c";
    RSA         *ca_rsa, *migration_pub_rsa, *maintenance_pub_rsa;/* OpenSSL objects */

    /* 完成OpenSSL的所有设置调用 */
    //init_external_libraries();
    /* SSL init*/
   //书中使用的init_external_libraries找不到函数,用别的方式代替
    SSL_library_init();
    /* load all SSL */
    OpenSSL_add_all_algorithms();
    /* load all SSL error message */
    SSL_load_error_strings();
    /*创建上下文句柄*/
    result=Tspi_Context_Create(&hContext);
    Debug("Create Context", result);
    /*获取上下文句柄,连接到本地TCS提供者*/
    result = Tspi_Context_Connect(hContext, NULL);
    Debug("Context Connect", result);
    /*获取TPM对象句柄*/
    result = Tspi_Context_GetTpmObject(hContext, &hTPM);
    Debug("Get TPM Handle", result);
    /*获取TPM策略对象,保存TPM所有者授权数据*/
    result=Tspi_GetPolicyObject(hTPM,TSS_POLICY_USAGE,&hownerpolicy);
    Debug("get ownerpolicy", result);
    result=Tspi_Policy_SetSecret(hownerpolicy,TSS_SECRET_MODE_POPUP,0,NULL);
    Debug("set owmerpolicy sercet", result);
    /*加载SRK*/
    result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, SRK_UUID, &hSRK);
    Debug("LOAD SRK", result);
    /*获取SRK策略*/  
    result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &hSRKPolicy);
    Debug("Get the SRK policy", result);
    /*设置SRK策略秘密细节*/  
    result=Tspi_Policy_SetSecret(hSRKPolicy,TSS_SECRET_MODE_POPUP,0,NULL);
    Debug("setSRK SECRET", result);
    /*使用SRK公钥封装软件生成的密钥,并将这个秘钥设置为一个需要口令的可迁移存储密钥*/
    initFlags = TSS_KEY_TYPE_STORAGE | TSS_KEY_MIGRATABLE | TSS_KEY_AUTHORIZATION;
    MyFunc_WrapKey(SOFTWARE_KEY_FILE_PATH, hSRK, initFlags, 0,&hUserSWMigKey);
    /*在用户永久存储区注册封装后的密钥*/
    result = Tspi_Context_RegisterKey(hContext, hUserSWMigKey,TSS_PS_TYPE_USER, swMigKeyUuid,TSS_PS_TYPE_SYSTEM, SRK_UUID);
    Debug("registerkey uermigkey :",result);
    /*使用迁移授权迁移一个密钥*/
    /*从一个文件中读取迁移授权的公钥*/
    migration_pub_rsa=openssl_read_key(MIMRATION_KEY_FILE_PATH);
    MyFunc_CreatePubKey(migration_pub_rsa,RSA_PKCS1_PADDING,&hMAKey);
    RSA_free(migration_pub_rsa);
    /*使用hMAKey创建一个迁移通行证*/
    result=Tspi_TPM_AuthorizeMigrationTicket(hTPM,hMAKey,TSS_MS_REWRAP,&ticketLen,&ticket);
    Debug("creat migrate ticket", result);
    /*使用迁移通行证把 hUserSWMigKey迁移到数据块中*/
    result=Tspi_Key_CreateMigrationBlob(hUserSWMigKey,hSRK,ticketLen,ticket,0,NULL,&migBlobLen,&migBlob);
    Debug("create migrateblob", result);
    printf("migBlobLen :%d\n",migBlobLen);
    //printf("migBlob:%s\n",migBlob);
    FILE *fp = fopen(file_name, "w");
    if(NULL == fp)
    {
      printf("File:\t%s Can Not Open To Write\n", file_name);
      exit(1);
    }
    printf("打开文件成功\n");
    if(fwrite(migBlob,sizeof(UINT32),migBlobLen, fp) < 0)
    {
      printf("File:\t%s Write Failed\n", file_name);
    }

    printf("写入数据\n");
    //Clean up  
    Tspi_Context_FreeMemory(hContext, NULL);
    Tspi_Context_Close(hContext);
    /*传输迁移数据*/
    // 声明并初始化一个服务器端的socket地址结构
  struct sockaddr_in server_addr;
  bzero(&server_addr, sizeof(server_addr));
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = htons(INADDR_ANY);
  server_addr.sin_port = htons(SERVER_PORT);

  // 创建socket,若成功,返回socket描述符
  int server_socket_fd = socket(PF_INET, SOCK_STREAM, 0);
  if(server_socket_fd < 0)
  {
    perror("Create Socket Failed:");
    exit(1);
  }
  int opt = 1;
  setsockopt(server_socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

  // 绑定socket和socket地址结构
  if(-1 == (bind(server_socket_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))
  {
    perror("Server Bind Failed:");
    exit(1);
  }

  // socket监听
  if(-1 == (listen(server_socket_fd, LENGTH_OF_LISTEN_QUEUE)))
  {
    perror("Server Listen Failed:");
    exit(1);
  }

  while(1)
  {
     // 定义客户端的socket地址结构
    struct sockaddr_in client_addr;
    socklen_t client_addr_length = sizeof(client_addr);
    // 接受连接请求,返回一个新的socket(描述符),这个新socket用于同连接的客户端通信
    // accept函数会把连接到的客户端信息写到client_addr中
    int new_server_socket_fd = accept(server_socket_fd, (struct sockaddr*)&client_addr, &client_addr_length);
    if(new_server_socket_fd < 0)
    {
      perror("Server Accept Failed:");
      break;
    }

    // recv函数接收数据到缓冲区buffer中
    char buffer[BUFFER_SIZE];
    bzero(buffer, BUFFER_SIZE);
    if(recv(new_server_socket_fd, buffer, BUFFER_SIZE, 0) < 0)
    {
      perror("Server Recieve Data Failed:");
      break;
    }

    // 然后从buffer(缓冲区)拷贝到file_name中
    char file_name[FILE_NAME_MAX_SIZE+1];
    bzero(file_name, FILE_NAME_MAX_SIZE+1);
    strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));
    printf("%s\n", file_name);

    // 打开文件并读取文件数据
    FILE *fp = fopen(file_name, "r");
    if(NULL == fp)
    {
      printf("File:%s Not Found\n", file_name);
    }
    else
    {
      bzero(buffer, BUFFER_SIZE);
      int length = 0;
      // 每读取一段数据,便将其发送给客户端,循环直到文件读完为止
      while((length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
      {
        if(send(new_server_socket_fd, buffer, length, 0) < 0)
        {
          printf("Send File:%s Failed./n", file_name);
          break;
        }
        bzero(buffer, BUFFER_SIZE);
      }
       // 关闭文件
      fclose(fp);
      printf("File:%s Transfer Successful!\n", file_name);
     }
     // 关闭与客户端的连接
     close(new_server_socket_fd);
    }
    // 关闭监听用的socket
    close(server_socket_fd);
    return 0;
}

目的tpm端file_client.c源代码:

#include<netinet/in.h>  // sockaddr_in
#include<sys/types.h>  // socket
#include<sys/socket.h>  // socket
#include<stdio.h>    // printf
#include<stdlib.h>    // exit
#include<string.h>    // bzero

#include<tss/tss_error.h>
#include<tss/platform.h>
#include<tss/tss_defines.h>
#include<tss/tss_typedef.h>
#include<tss/tss_structs.h>
#include<tss/tspi.h>
#include<trousers/trousers.h>

#define SERVER_PORT 8000
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512
   
#define Debug(message,tResult) printf("%s: %s\n",message,(char *)Trspi_Error_String(result))
int main()
{
 
  BYTE               *migBlob;
  TSS_RESULT         result;
  TSS_HKEY           hSRK,hKeyToMigrate;
  UINT32             migBlobLen=32667;
  TSS_HCONTEXT       hContext;
  TSS_HTPM           hTPM;
  TSS_HPOLICY        hSRKPolicy,hownerpolicy;
  TSS_UUID           SRK_UUID=TSS_UUID_SRK,MigKeyUuid;
  // 声明并初始化一个客户端的socket地址结构
  struct sockaddr_in client_addr;
  bzero(&client_addr, sizeof(client_addr));
  client_addr.sin_family = AF_INET;
  client_addr.sin_addr.s_addr = htons(INADDR_ANY);
  client_addr.sin_port = htons(0);  
  // 创建socket,若成功,返回socket描述符
  int client_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
  if(client_socket_fd < 0)
  {
    perror("Create Socket Failed:");
    exit(1);
  }
   
  // 绑定客户端的socket和客户端的socket地址结构 非必需
  if(-1 == (bind(client_socket_fd, (struct sockaddr*)&client_addr, sizeof(client_addr))))
  {
    perror("Client Bind Failed:");
    exit(1);
  }
   
  // 声明一个服务器端的socket地址结构,并用服务器那边的IP地址及端口对其进行初始化,用于后面的连接
  struct sockaddr_in server_addr;
  bzero(&server_addr, sizeof(server_addr));
  server_addr.sin_family = AF_INET;
  if(inet_pton(AF_INET, "169.254.12.125", &server_addr.sin_addr) == 0)
  {
    perror("Server IP Address Error:");
    exit(1);
  }
  server_addr.sin_port = htons(SERVER_PORT);
  socklen_t server_addr_length = sizeof(server_addr);
   
  // 向服务器发起连接,连接成功后client_socket_fd代表了客户端和服务器的一个socket连接
  if(connect(client_socket_fd, (struct sockaddr*)&server_addr, server_addr_length) < 0)
  {
    perror("Can Not Connect To Server IP:");
    exit(0);
  }
   
  // 输入文件名 并放到缓冲区buffer中等待发送
  char file_name[FILE_NAME_MAX_SIZE+1];
  bzero(file_name, FILE_NAME_MAX_SIZE+1);
  printf("Please Input File Name On Server:\t");
  scanf("%s", file_name);
   
  char buffer[BUFFER_SIZE];
  bzero(buffer, BUFFER_SIZE);
  strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name));
     
  // 向服务器发送buffer中的数据
  if(send(client_socket_fd, buffer, BUFFER_SIZE, 0) < 0)
  {
    perror("Send File Name Failed:");
    exit(1);
  }
   
  // 打开文件,准备写入
  FILE *fp = fopen(file_name, "w");
  if(NULL == fp)
  {
    printf("File:\t%s Can Not Open To Write\n", file_name);
    exit(1);
  }
   
  // 从服务器接收数据到buffer中
  // 每接收一段数据,便将其写入文件中,循环直到文件接收完并写完为止
  bzero(buffer, BUFFER_SIZE);
  int length = 0;
  while((length = recv(client_socket_fd, buffer, BUFFER_SIZE, 0)) > 0)
  {
    if(fwrite(buffer, sizeof(char), length, fp) < length)
    {
      printf("File:\t%s Write Failed\n", file_name);
      break;
    }
    bzero(buffer, BUFFER_SIZE);
  }
   
  // 接收成功后,关闭文件,关闭socket
  printf("Receive File:\t%s From Server IP Successful!\n", file_name);
  close(fp);
  close(client_socket_fd);
  /*读取文件中的迁移数据*/
   char    file[512]="./tpm.c";
   FILE *fp1=fopen(file,"w");
   if(NULL==fp1){
      printf("file:\t%s can not open \n",file);
      exit(1);
   }
   else{
      printf("打开文件成功\n");
   }
   /*将迁移数据读取到migBlob*/
   if(fread(migBlob,sizeof(BYTE),migBlobLen,fp1)<0){
      printf("file:\t%s read failed\n",file);
   }
   /*解密迁移数据*/
   result=Tspi_Context_Create(&hContext);
   Debug("create context",result);
   result=Tspi_Context_Connect(hContext,NULL);
   Debug("get connect",result);
   result=Tspi_Context_GetTpmObject(hContext,&hTPM);
   Debug("get tpm handle",result);
   result=Tspi_GetPolicyObject(hTPM,TSS_POLICY_USAGE,&hownerpolicy);
   Debug("get ownerpolicy",result);
   result=Tspi_Policy_SetSecret(hownerpolicy,TSS_SECRET_MODE_POPUP,0,NULL);
   Debug("set ownerpolicy sercet",result);
   result=Tspi_Context_LoadKeyByUUID(hContext,TSS_PS_TYPE_SYSTEM,SRK_UUID,&hSRK);
   Debug("load srk",result);
   result=Tspi_GetPolicyObject(hSRK,TSS_POLICY_USAGE,&hSRKPolicy);
   Debug("get srk policy",result);
   result=Tspi_Policy_SetSecret(hSRKPolicy,TSS_SECRET_MODE_POPUP,0,NULL);
   Debug("set srkpolicy sercet",result);
   result=Tspi_Key_ConvertMigrationBlob(hKeyToMigrate,hSRK,0,0,migBlobLen,migBlob);
   Debug("covert migblob data",result);

   return 0;
}

编译运行:gcc -g -o  key key.c -ltspi -lcrypto -lssl     

                    gcc file_client.c  -o mig -ltspi

                    ./key

                   ./mig

错误总结:

未完待续……………………

 

 

 

 

 

 

 

 

 

 

 

 

© 著作权归作者所有

粉丝 2
博文 19
码字总数 37798
作品 0
成都
私信 提问
OpenSSL 1.1 API 的迁移问题

很多人都知道,OpenSSL 1.1.0版本有意介绍了从以前的版本引入了重大的API更改,以前公开可见的大量数据结构已经变得不透明,添加了访问器函数以获取和设置这些现在不透明结构中的一些字段。值...

两味真火
2016/12/31
1K
2
在 Gentoo 中使用 Yubikey PGP 卡

本文环境 OS:Gentoo 内核:4.9.76 gpg (GnuPG): 2.2.4 yubikey-manager: 0.6.0 pcsc-tools: 1.4.27 什么是 PGP 卡? 在加密技术中,PGP 卡是一种智能卡,这种智能卡可以执行加密、解密、...

00%
2018/05/16
0
0
centos7.3编译安装OpenSSL1.1.1b

简介 OpenSSL是一个开放源代码的软件库包,应用程序可以使用这个包来进行安全通信,避免窃听,同时确认另一端连接者的身份。这个包广泛被应用在互联网的网页服务器上。 安装 下载:下载地址 ...

阿dai学长
03/24
147
0
Linux openssh openssl

Linux openssh openssl 笔记日期20180524 目录 openssh 配置ssh基于密钥的方式认证 服务器端配置文件 ssh服务的最佳实践 OpenSSL 三个组件 PKI: Public Key Infrastructure 建立私有CA 证书申...

Winthcloud
2018/06/29
0
0
openssl7月9号高危漏洞

Openssl 7月9日发布了 OpenSSL 1.0.2 和OpenSSL 1.0.1 两个主线版本的更新,其中修复了一个高危安全问题(CVE-2015-1793)。 漏洞危害: 特定版本的OpenSSL在证书校验的逻辑中存在安全漏洞,使...

gaolongquan
2015/07/09
115
0

没有更多内容

加载失败,请刷新页面

加载更多

自定义ApiBoot Logging链路以及单元ID生成策略

ApiBoot Logging会为每一个请求都对应创建链路编号(TraceID)以及单元编号(SpanID),用于归类每一次请求日志,通过一个链路下日志单元的Parent SpanID可以进行上下级关系的梳理。 前文回顾...

恒宇少年
18分钟前
6
0
浅谈 Application 和 activity

对于 在 Application初始化一些变量,为什么不可以放在activity 或者其他的组件里呢? 这里就根据个人的理解来讲述一下,欢迎补充指正。 首先 activity 是以栈的形式出现,一个app应用会有多...

MrLins
18分钟前
5
0
Allegro的脚本文件内容里都有哪些

小伙伴们在使用Allegro的时候是否经常用到脚本文件夹呢?scr的用法其实可真不简单。。。 首先脚本文件的运行模式就存在很多种,比如不提示错误信息,不弹出确认对画框(这样很有利于我们执行...

demyar
19分钟前
12
0
微信升级外链管理规范,「砍一刀帮我加速」要被禁止了

原创: 蒋鸿昌 首发:「知晓程序」公众号 - 最好的微信新商业媒体 几天前,知名互联网评论人阑夕模仿皮尤研究中心(Pew Research Center)在美国做的互联网通识调查问卷,做了一份中文版问卷...

知晓云
20分钟前
8
0
CentOS 7接投影仪

我将一台安装着CentOS 7图形界面的惠普笔记本电脑当桌面使用。最近,想要连接投影仪时却遇到了问题。笔记本有一个HDMI接口。我买了一个HDMI---->VGA的转接线,连上笔记本电脑后,屏幕一直在闪...

大别阿郎
24分钟前
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部