1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
/*
* Copyright (c) 2010-2012 United States Government, as represented by
* the Secretary of Defense. All rights reserved.
*
* THIS SOFTWARE AND ITS DOCUMENTATION ARE PROVIDED AS IS AND WITHOUT
* ANY EXPRESS OR IMPLIED WARRANTIES WHATSOEVER. ALL WARRANTIES
* INCLUDING, BUT NOT LIMITED TO, PERFORMANCE, MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT ARE HEREBY
* DISCLAIMED. USERS ASSUME THE ENTIRE RISK AND LIABILITY OF USING THE
* SOFTWARE.
*/
#include <types.h>
#include <xen/xen.h>
#include <mm.h>
#include <gnttab.h>
#include "tpm/tpm_marshalling.h"
#include "vtpm_manager.h"
#include "vtpm_cmd.h"
#include <tpmback.h>
#define TRYFAILGOTO(C) \
if((C)) { \
status = TPM_FAIL; \
goto abort_egress; \
}
#define TRYFAILGOTOMSG(C, msg) \
if((C)) { \
status = TPM_FAIL; \
error(msg); \
goto abort_egress; \
}
#define CHECKSTATUSGOTO(ret, fname) \
if((ret) != TPM_SUCCESS) { \
error("%s failed with error code (%lu)", fname, (unsigned long) ret); \
status = ord; \
goto abort_egress; \
}
#define ERR_MALFORMED "Malformed response from backend"
#define ERR_TPMFRONT "Error sending command through frontend device"
struct shpage {
void* page;
grant_ref_t grantref;
};
typedef struct shpage shpage_t;
static inline int pack_header(uint8_t** bptr, UINT32* len, TPM_TAG tag, UINT32 size, TPM_COMMAND_CODE ord)
{
return *bptr == NULL ||
tpm_marshal_UINT16(bptr, len, tag) ||
tpm_marshal_UINT32(bptr, len, size) ||
tpm_marshal_UINT32(bptr, len, ord);
}
static inline int unpack_header(uint8_t** bptr, UINT32* len, TPM_TAG* tag, UINT32* size, TPM_COMMAND_CODE* ord)
{
return *bptr == NULL ||
tpm_unmarshal_UINT16(bptr, len, tag) ||
tpm_unmarshal_UINT32(bptr, len, size) ||
tpm_unmarshal_UINT32(bptr, len, ord);
}
int create_error_response(tpmcmd_t* tpmcmd, TPM_RESULT errorcode)
{
TPM_TAG tag;
UINT32 len = tpmcmd->req_len;
uint8_t* respptr;
uint8_t* cmdptr = tpmcmd->req;
if(!tpm_unmarshal_UINT16(&cmdptr, &len, &tag)) {
switch (tag) {
case TPM_TAG_RQU_COMMAND:
tag = TPM_TAG_RSP_COMMAND;
break;
case TPM_TAG_RQU_AUTH1_COMMAND:
tag = TPM_TAG_RQU_AUTH2_COMMAND;
break;
case TPM_TAG_RQU_AUTH2_COMMAND:
tag = TPM_TAG_RQU_AUTH2_COMMAND;
break;
}
} else {
tag = TPM_TAG_RSP_COMMAND;
}
tpmcmd->resp_len = len = 10;
tpmcmd->resp = respptr = tpm_malloc(tpmcmd->resp_len);
return pack_header(&respptr, &len, tag, len, errorcode);
}
TPM_RESULT VTPM_GetRandom(struct tpmfront_dev* tpmfront_dev, BYTE* bytes, UINT32 *numbytes) {
TPM_RESULT status = TPM_SUCCESS;
uint8_t* cmdbuf, *resp, *bptr;
size_t resplen = 0;
UINT32 len;
/*Ask the real tpm for random bytes for the seed */
TPM_TAG tag = TPM_TAG_RQU_COMMAND;
UINT32 size;
TPM_COMMAND_CODE ord = TPM_ORD_GetRandom;
len = size = sizeof(TPM_TAG) + sizeof(UINT32) + sizeof(TPM_COMMAND_CODE) + sizeof(UINT32);
/*Create the raw tpm command */
bptr = cmdbuf = malloc(size);
TRYFAILGOTO(pack_header(&bptr, &len, tag, size, ord));
TRYFAILGOTO(tpm_marshal_UINT32(&bptr, &len, *numbytes));
/* Send cmd, wait for response */
TRYFAILGOTOMSG(tpmfront_cmd(tpmfront_dev, cmdbuf, size, &resp, &resplen),
ERR_TPMFRONT);
bptr = resp; len = resplen;
TRYFAILGOTOMSG(unpack_header(&bptr, &len, &tag, &size, &ord), ERR_MALFORMED);
//Check return status of command
CHECKSTATUSGOTO(ord, "TPM_GetRandom()");
// Get the number of random bytes in the response
TRYFAILGOTOMSG(tpm_unmarshal_UINT32(&bptr, &len, &size), ERR_MALFORMED);
*numbytes = size;
//Get the random bytes out, tpm may give us less bytes than what we wanrt
TRYFAILGOTOMSG(tpm_unmarshal_BYTE_ARRAY(&bptr, &len, bytes, *numbytes), ERR_MALFORMED);
goto egress;
abort_egress:
egress:
free(cmdbuf);
return status;
}
TPM_RESULT VTPM_LoadHashKey(struct tpmfront_dev* tpmfront_dev, uint8_t** data, size_t* data_length)
{
TPM_RESULT status = TPM_SUCCESS;
uint8_t* bptr, *resp;
uint8_t* cmdbuf = NULL;
size_t resplen = 0;
UINT32 len;
TPM_TAG tag = VTPM_TAG_REQ;
UINT32 size;
TPM_COMMAND_CODE ord = VTPM_ORD_LOADHASHKEY;
/*Create the command*/
len = size = VTPM_COMMAND_HEADER_SIZE;
bptr = cmdbuf = malloc(size);
TRYFAILGOTO(pack_header(&bptr, &len, tag, size, ord));
/* Send the command to vtpm_manager */
info("Requesting Encryption key from backend");
TRYFAILGOTOMSG(tpmfront_cmd(tpmfront_dev, cmdbuf, size, &resp, &resplen), ERR_TPMFRONT);
/* Unpack response header */
bptr = resp;
len = resplen;
TRYFAILGOTOMSG(unpack_header(&bptr, &len, &tag, &size, &ord), ERR_MALFORMED);
/* Check return code */
CHECKSTATUSGOTO(ord, "VTPM_LoadHashKey()");
/* Get the size of the key */
*data_length = size - VTPM_COMMAND_HEADER_SIZE;
/* Copy the key bits */
*data = malloc(*data_length);
memcpy(*data, bptr, *data_length);
goto egress;
abort_egress:
error("VTPM_LoadHashKey failed");
egress:
free(cmdbuf);
return status;
}
TPM_RESULT VTPM_SaveHashKey(struct tpmfront_dev* tpmfront_dev, uint8_t* data, size_t data_length)
{
TPM_RESULT status = TPM_SUCCESS;
uint8_t* bptr, *resp;
uint8_t* cmdbuf = NULL;
size_t resplen = 0;
UINT32 len;
TPM_TAG tag = VTPM_TAG_REQ;
UINT32 size;
TPM_COMMAND_CODE ord = VTPM_ORD_SAVEHASHKEY;
/*Create the command*/
len = size = VTPM_COMMAND_HEADER_SIZE + data_length;
bptr = cmdbuf = malloc(size);
TRYFAILGOTO(pack_header(&bptr, &len, tag, size, ord));
memcpy(bptr, data, data_length);
bptr += data_length;
/* Send the command to vtpm_manager */
info("Sending encryption key to backend");
TRYFAILGOTOMSG(tpmfront_cmd(tpmfront_dev, cmdbuf, size, &resp, &resplen), ERR_TPMFRONT);
/* Unpack response header */
bptr = resp;
len = resplen;
TRYFAILGOTOMSG(unpack_header(&bptr, &len, &tag, &size, &ord), ERR_MALFORMED);
/* Check return code */
CHECKSTATUSGOTO(ord, "VTPM_SaveHashKey()");
goto egress;
abort_egress:
error("VTPM_SaveHashKey failed");
egress:
free(cmdbuf);
return status;
}
TPM_RESULT VTPM_PCRRead(struct tpmfront_dev* tpmfront_dev, UINT32 pcrIndex, BYTE* outDigest)
{
TPM_RESULT status = TPM_SUCCESS;
uint8_t *cmdbuf, *resp, *bptr;
size_t resplen = 0;
UINT32 len;
/*Just send a TPM_PCRRead Command to the HW tpm */
TPM_TAG tag = TPM_TAG_RQU_COMMAND;
UINT32 size;
TPM_COMMAND_CODE ord = TPM_ORD_PCRRead;
len = size = sizeof(TPM_TAG) + sizeof(UINT32) + sizeof(TPM_COMMAND_CODE) + sizeof(UINT32);
/*Create the raw tpm cmd */
bptr = cmdbuf = malloc(size);
TRYFAILGOTO(pack_header(&bptr, &len, tag, size, ord));
TRYFAILGOTO(tpm_marshal_UINT32(&bptr, &len, pcrIndex));
/*Send Cmd wait for response */
TRYFAILGOTOMSG(tpmfront_cmd(tpmfront_dev, cmdbuf, size, &resp, &resplen), ERR_TPMFRONT);
bptr = resp; len = resplen;
TRYFAILGOTOMSG(unpack_header(&bptr, &len, &tag, &size, &ord), ERR_MALFORMED);
//Check return status of command
CHECKSTATUSGOTO(ord, "TPM_PCRRead");
//Get the ptr value
memcpy(outDigest, bptr, sizeof(TPM_PCRVALUE));
goto egress;
abort_egress:
egress:
free(cmdbuf);
return status;
}
|
