2 * TPM utility functions
4 * Copyright (c) 2010 - 2015 IBM Corporation
6 * Stefan Berger <stefanb@us.ibm.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, see <http://www.gnu.org/licenses/>
22 #include "qemu/osdep.h"
23 #include "qemu/error-report.h"
24 #include "qapi/error.h"
25 #include "qapi/visitor.h"
27 #include "exec/memory.h"
28 #include "hw/qdev-properties.h"
29 #include "sysemu/tpm_backend.h"
30 #include "sysemu/tpm_util.h"
33 /* tpm backend property */
35 static void get_tpm(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
38 TPMBackend
**be
= object_field_prop_ptr(obj
, opaque
);
41 p
= g_strdup(*be
? (*be
)->id
: "");
42 visit_type_str(v
, name
, &p
, errp
);
46 static void set_tpm(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
49 Property
*prop
= opaque
;
50 TPMBackend
*s
, **be
= object_field_prop_ptr(obj
, prop
);
53 if (!visit_type_str(v
, name
, &str
, errp
)) {
57 s
= qemu_find_tpm_be(str
);
59 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
60 object_get_typename(obj
), name
, str
);
61 } else if (tpm_backend_init(s
, TPM_IF(obj
), errp
) == 0) {
62 *be
= s
; /* weak reference, avoid cyclic ref */
67 static void release_tpm(Object
*obj
, const char *name
, void *opaque
)
69 Property
*prop
= opaque
;
70 TPMBackend
**be
= object_field_prop_ptr(obj
, prop
);
73 tpm_backend_reset(*be
);
77 const PropertyInfo qdev_prop_tpm
= {
79 .description
= "ID of a tpm to use as a backend",
82 .release
= release_tpm
,
86 * Write an error message in the given output buffer.
88 void tpm_util_write_fatal_error_response(uint8_t *out
, uint32_t out_len
)
90 if (out_len
>= sizeof(struct tpm_resp_hdr
)) {
91 tpm_cmd_set_tag(out
, TPM_TAG_RSP_COMMAND
);
92 tpm_cmd_set_size(out
, sizeof(struct tpm_resp_hdr
));
93 tpm_cmd_set_error(out
, TPM_FAIL
);
97 bool tpm_util_is_selftest(const uint8_t *in
, uint32_t in_len
)
99 if (in_len
>= sizeof(struct tpm_req_hdr
)) {
100 return tpm_cmd_get_ordinal(in
) == TPM_ORD_ContinueSelfTest
;
107 * Send request to a TPM device. We expect a response within one second.
109 static int tpm_util_request(int fd
,
115 GPollFD fds
[1] = { {.fd
= fd
, .events
= G_IO_IN
} };
118 n
= write(fd
, request
, requestlen
);
122 if (n
!= requestlen
) {
126 /* wait for a second */
127 n
= RETRY_ON_EINTR(g_poll(fds
, 1, 1000));
132 n
= read(fd
, response
, responselen
);
133 if (n
< sizeof(struct tpm_resp_hdr
)) {
137 /* check the header */
138 if (tpm_cmd_get_size(response
) != n
) {
146 * A basic test of a TPM device. We expect a well formatted response header
147 * (error response is fine).
149 static int tpm_util_test(int fd
,
152 uint16_t *return_tag
)
157 ret
= tpm_util_request(fd
, request
, requestlen
,
163 *return_tag
= tpm_cmd_get_tag(buf
);
169 * Probe for the TPM device in the back
170 * Returns 0 on success with the version of the probed TPM set, 1 on failure.
172 int tpm_util_test_tpmdev(int tpm_fd
, TPMVersion
*tpm_version
)
175 * Sending a TPM1.2 command to a TPM2 should return a TPM1.2
176 * header (tag = 0xc4) and error code (TPM_BADTAG = 0x1e)
178 * Sending a TPM2 command to a TPM 2 will give a TPM 2 tag in the
180 * Sending a TPM2 command to a TPM 1.2 will give a TPM 1.2 tag
181 * in the header and an error code.
183 const struct tpm_req_hdr test_req
= {
184 .tag
= cpu_to_be16(TPM_TAG_RQU_COMMAND
),
185 .len
= cpu_to_be32(sizeof(test_req
)),
186 .ordinal
= cpu_to_be32(TPM_ORD_GetTicks
),
189 const struct tpm_req_hdr test_req_tpm2
= {
190 .tag
= cpu_to_be16(TPM2_ST_NO_SESSIONS
),
191 .len
= cpu_to_be32(sizeof(test_req_tpm2
)),
192 .ordinal
= cpu_to_be32(TPM2_CC_ReadClock
),
197 /* Send TPM 2 command */
198 ret
= tpm_util_test(tpm_fd
, &test_req_tpm2
,
199 sizeof(test_req_tpm2
), &return_tag
);
200 /* TPM 2 would respond with a tag of TPM2_ST_NO_SESSIONS */
201 if (!ret
&& return_tag
== TPM2_ST_NO_SESSIONS
) {
202 *tpm_version
= TPM_VERSION_2_0
;
206 /* Send TPM 1.2 command */
207 ret
= tpm_util_test(tpm_fd
, &test_req
,
208 sizeof(test_req
), &return_tag
);
209 if (!ret
&& return_tag
== TPM_TAG_RSP_COMMAND
) {
210 *tpm_version
= TPM_VERSION_1_2
;
211 /* this is a TPM 1.2 */
215 *tpm_version
= TPM_VERSION_UNSPEC
;
220 int tpm_util_get_buffer_size(int tpm_fd
, TPMVersion tpm_version
,
225 switch (tpm_version
) {
226 case TPM_VERSION_1_2
: {
227 const struct tpm_req_get_buffer_size
{
228 struct tpm_req_hdr hdr
;
232 } QEMU_PACKED tpm_get_buffer_size
= {
234 .tag
= cpu_to_be16(TPM_TAG_RQU_COMMAND
),
235 .len
= cpu_to_be32(sizeof(tpm_get_buffer_size
)),
236 .ordinal
= cpu_to_be32(TPM_ORD_GetCapability
),
238 .capability
= cpu_to_be32(TPM_CAP_PROPERTY
),
239 .len
= cpu_to_be32(sizeof(uint32_t)),
240 .subcap
= cpu_to_be32(TPM_CAP_PROP_INPUT_BUFFER
),
242 struct tpm_resp_get_buffer_size
{
243 struct tpm_resp_hdr hdr
;
246 } QEMU_PACKED tpm_resp
;
248 ret
= tpm_util_request(tpm_fd
, &tpm_get_buffer_size
,
249 sizeof(tpm_get_buffer_size
),
250 &tpm_resp
, sizeof(tpm_resp
));
255 if (be32_to_cpu(tpm_resp
.hdr
.len
) != sizeof(tpm_resp
) ||
256 be32_to_cpu(tpm_resp
.len
) != sizeof(uint32_t)) {
257 trace_tpm_util_get_buffer_size_hdr_len(
258 be32_to_cpu(tpm_resp
.hdr
.len
),
260 trace_tpm_util_get_buffer_size_len(be32_to_cpu(tpm_resp
.len
),
262 error_report("tpm_util: Got unexpected response to "
263 "TPM_GetCapability; errcode: 0x%x",
264 be32_to_cpu(tpm_resp
.hdr
.errcode
));
267 *buffersize
= be32_to_cpu(tpm_resp
.buffersize
);
270 case TPM_VERSION_2_0
: {
271 const struct tpm2_req_get_buffer_size
{
272 struct tpm_req_hdr hdr
;
276 } QEMU_PACKED tpm2_get_buffer_size
= {
278 .tag
= cpu_to_be16(TPM2_ST_NO_SESSIONS
),
279 .len
= cpu_to_be32(sizeof(tpm2_get_buffer_size
)),
280 .ordinal
= cpu_to_be32(TPM2_CC_GetCapability
),
282 .capability
= cpu_to_be32(TPM2_CAP_TPM_PROPERTIES
),
283 .property
= cpu_to_be32(TPM2_PT_MAX_COMMAND_SIZE
),
284 .count
= cpu_to_be32(2), /* also get TPM2_PT_MAX_RESPONSE_SIZE */
286 struct tpm2_resp_get_buffer_size
{
287 struct tpm_resp_hdr hdr
;
295 } QEMU_PACKED tpm2_resp
;
297 ret
= tpm_util_request(tpm_fd
, &tpm2_get_buffer_size
,
298 sizeof(tpm2_get_buffer_size
),
299 &tpm2_resp
, sizeof(tpm2_resp
));
304 if (be32_to_cpu(tpm2_resp
.hdr
.len
) != sizeof(tpm2_resp
) ||
305 be32_to_cpu(tpm2_resp
.count
) != 2) {
306 trace_tpm_util_get_buffer_size_hdr_len2(
307 be32_to_cpu(tpm2_resp
.hdr
.len
),
309 trace_tpm_util_get_buffer_size_len2(
310 be32_to_cpu(tpm2_resp
.count
), 2);
311 error_report("tpm_util: Got unexpected response to "
312 "TPM2_GetCapability; errcode: 0x%x",
313 be32_to_cpu(tpm2_resp
.hdr
.errcode
));
316 *buffersize
= MAX(be32_to_cpu(tpm2_resp
.value1
),
317 be32_to_cpu(tpm2_resp
.value2
));
320 case TPM_VERSION_UNSPEC
:
324 trace_tpm_util_get_buffer_size(*buffersize
);
329 void tpm_sized_buffer_reset(TPMSizedBuffer
*tsb
)
336 void tpm_util_show_buffer(const unsigned char *buffer
,
337 size_t buffer_size
, const char *string
)
340 char *line_buffer
, *p
;
342 if (!trace_event_get_state_backends(TRACE_TPM_UTIL_SHOW_BUFFER
)) {
345 len
= MIN(tpm_cmd_get_size(buffer
), buffer_size
);
348 * allocate enough room for 3 chars per buffer entry plus a
349 * newline after every 16 chars and a final null terminator.
351 line_buffer
= g_malloc(len
* 3 + (len
/ 16) + 1);
353 for (i
= 0, p
= line_buffer
; i
< len
; i
++) {
354 if (i
&& !(i
% 16)) {
355 p
+= sprintf(p
, "\n");
357 p
+= sprintf(p
, "%.2X ", buffer
[i
]);
359 trace_tpm_util_show_buffer(string
, len
, line_buffer
);