1 /*
2 * QEMU SEV support
3 *
4 * Copyright Advanced Micro Devices 2016-2018
5 *
6 * Author:
7 * Brijesh Singh <brijesh.singh@amd.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15
16 #include <linux/kvm.h>
17 #include <linux/psp-sev.h>
18
19 #include <sys/ioctl.h>
20
21 #include "qapi/error.h"
22 #include "qom/object_interfaces.h"
23 #include "qemu/base64.h"
24 #include "qemu/module.h"
25 #include "qemu/uuid.h"
26 #include "qemu/error-report.h"
27 #include "crypto/hash.h"
28 #include "sysemu/kvm.h"
29 #include "kvm/kvm_i386.h"
30 #include "sev.h"
31 #include "sysemu/sysemu.h"
32 #include "sysemu/runstate.h"
33 #include "trace.h"
34 #include "migration/blocker.h"
35 #include "qom/object.h"
36 #include "monitor/monitor.h"
37 #include "monitor/hmp-target.h"
38 #include "qapi/qapi-commands-misc-target.h"
39 #include "confidential-guest.h"
40 #include "hw/i386/pc.h"
41 #include "exec/address-spaces.h"
42
43 #define TYPE_SEV_GUEST "sev-guest"
44 OBJECT_DECLARE_SIMPLE_TYPE(SevGuestState, SEV_GUEST)
45
46
47 /**
48 * SevGuestState:
49 *
50 * The SevGuestState object is used for creating and managing a SEV
51 * guest.
52 *
53 * # $QEMU \
54 * -object sev-guest,id=sev0 \
55 * -machine ...,memory-encryption=sev0
56 */
57 struct SevGuestState {
58 X86ConfidentialGuest parent_obj;
59
60 int kvm_type;
61
62 /* configuration parameters */
63 char *sev_device;
64 uint32_t policy;
65 char *dh_cert_file;
66 char *session_file;
67 uint32_t cbitpos;
68 uint32_t reduced_phys_bits;
69 bool kernel_hashes;
70 bool legacy_vm_type;
71
72 /* runtime state */
73 uint32_t handle;
74 uint8_t api_major;
75 uint8_t api_minor;
76 uint8_t build_id;
77 int sev_fd;
78 SevState state;
79 gchar *measurement;
80
81 uint32_t reset_cs;
82 uint32_t reset_ip;
83 bool reset_data_valid;
84 };
85
86 #define DEFAULT_GUEST_POLICY 0x1 /* disable debug */
87 #define DEFAULT_SEV_DEVICE "/dev/sev"
88
89 #define SEV_INFO_BLOCK_GUID "00f771de-1a7e-4fcb-890e-68c77e2fb44e"
90 typedef struct __attribute__((__packed__)) SevInfoBlock {
91 /* SEV-ES Reset Vector Address */
92 uint32_t reset_addr;
93 } SevInfoBlock;
94
95 #define SEV_HASH_TABLE_RV_GUID "7255371f-3a3b-4b04-927b-1da6efa8d454"
96 typedef struct QEMU_PACKED SevHashTableDescriptor {
97 /* SEV hash table area guest address */
98 uint32_t base;
99 /* SEV hash table area size (in bytes) */
100 uint32_t size;
101 } SevHashTableDescriptor;
102
103 /* hard code sha256 digest size */
104 #define HASH_SIZE 32
105
106 typedef struct QEMU_PACKED SevHashTableEntry {
107 QemuUUID guid;
108 uint16_t len;
109 uint8_t hash[HASH_SIZE];
110 } SevHashTableEntry;
111
112 typedef struct QEMU_PACKED SevHashTable {
113 QemuUUID guid;
114 uint16_t len;
115 SevHashTableEntry cmdline;
116 SevHashTableEntry initrd;
117 SevHashTableEntry kernel;
118 } SevHashTable;
119
120 /*
121 * Data encrypted by sev_encrypt_flash() must be padded to a multiple of
122 * 16 bytes.
123 */
124 typedef struct QEMU_PACKED PaddedSevHashTable {
125 SevHashTable ht;
126 uint8_t padding[ROUND_UP(sizeof(SevHashTable), 16) - sizeof(SevHashTable)];
127 } PaddedSevHashTable;
128
129 QEMU_BUILD_BUG_ON(sizeof(PaddedSevHashTable) % 16 != 0);
130
131 static SevGuestState *sev_guest;
132 static Error *sev_mig_blocker;
133
134 static const char *const sev_fw_errlist[] = {
135 [SEV_RET_SUCCESS] = "",
136 [SEV_RET_INVALID_PLATFORM_STATE] = "Platform state is invalid",
137 [SEV_RET_INVALID_GUEST_STATE] = "Guest state is invalid",
138 [SEV_RET_INAVLID_CONFIG] = "Platform configuration is invalid",
139 [SEV_RET_INVALID_LEN] = "Buffer too small",
140 [SEV_RET_ALREADY_OWNED] = "Platform is already owned",
141 [SEV_RET_INVALID_CERTIFICATE] = "Certificate is invalid",
142 [SEV_RET_POLICY_FAILURE] = "Policy is not allowed",
143 [SEV_RET_INACTIVE] = "Guest is not active",
144 [SEV_RET_INVALID_ADDRESS] = "Invalid address",
145 [SEV_RET_BAD_SIGNATURE] = "Bad signature",
146 [SEV_RET_BAD_MEASUREMENT] = "Bad measurement",
147 [SEV_RET_ASID_OWNED] = "ASID is already owned",
148 [SEV_RET_INVALID_ASID] = "Invalid ASID",
149 [SEV_RET_WBINVD_REQUIRED] = "WBINVD is required",
150 [SEV_RET_DFFLUSH_REQUIRED] = "DF_FLUSH is required",
151 [SEV_RET_INVALID_GUEST] = "Guest handle is invalid",
152 [SEV_RET_INVALID_COMMAND] = "Invalid command",
153 [SEV_RET_ACTIVE] = "Guest is active",
154 [SEV_RET_HWSEV_RET_PLATFORM] = "Hardware error",
155 [SEV_RET_HWSEV_RET_UNSAFE] = "Hardware unsafe",
156 [SEV_RET_UNSUPPORTED] = "Feature not supported",
157 [SEV_RET_INVALID_PARAM] = "Invalid parameter",
158 [SEV_RET_RESOURCE_LIMIT] = "Required firmware resource depleted",
159 [SEV_RET_SECURE_DATA_INVALID] = "Part-specific integrity check failure",
160 };
161
162 #define SEV_FW_MAX_ERROR ARRAY_SIZE(sev_fw_errlist)
163
164 static int
sev_ioctl(int fd,int cmd,void * data,int * error)165 sev_ioctl(int fd, int cmd, void *data, int *error)
166 {
167 int r;
168 struct kvm_sev_cmd input;
169
170 memset(&input, 0x0, sizeof(input));
171
172 input.id = cmd;
173 input.sev_fd = fd;
174 input.data = (uintptr_t)data;
175
176 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, &input);
177
178 if (error) {
179 *error = input.error;
180 }
181
182 return r;
183 }
184
185 static int
sev_platform_ioctl(int fd,int cmd,void * data,int * error)186 sev_platform_ioctl(int fd, int cmd, void *data, int *error)
187 {
188 int r;
189 struct sev_issue_cmd arg;
190
191 arg.cmd = cmd;
192 arg.data = (unsigned long)data;
193 r = ioctl(fd, SEV_ISSUE_CMD, &arg);
194 if (error) {
195 *error = arg.error;
196 }
197
198 return r;
199 }
200
201 static const char *
fw_error_to_str(int code)202 fw_error_to_str(int code)
203 {
204 if (code < 0 || code >= SEV_FW_MAX_ERROR) {
205 return "unknown error";
206 }
207
208 return sev_fw_errlist[code];
209 }
210
211 static bool
sev_check_state(const SevGuestState * sev,SevState state)212 sev_check_state(const SevGuestState *sev, SevState state)
213 {
214 assert(sev);
215 return sev->state == state ? true : false;
216 }
217
218 static void
sev_set_guest_state(SevGuestState * sev,SevState new_state)219 sev_set_guest_state(SevGuestState *sev, SevState new_state)
220 {
221 assert(new_state < SEV_STATE__MAX);
222 assert(sev);
223
224 trace_kvm_sev_change_state(SevState_str(sev->state),
225 SevState_str(new_state));
226 sev->state = new_state;
227 }
228
229 static void
sev_ram_block_added(RAMBlockNotifier * n,void * host,size_t size,size_t max_size)230 sev_ram_block_added(RAMBlockNotifier *n, void *host, size_t size,
231 size_t max_size)
232 {
233 int r;
234 struct kvm_enc_region range;
235 ram_addr_t offset;
236 MemoryRegion *mr;
237
238 /*
239 * The RAM device presents a memory region that should be treated
240 * as IO region and should not be pinned.
241 */
242 mr = memory_region_from_host(host, &offset);
243 if (mr && memory_region_is_ram_device(mr)) {
244 return;
245 }
246
247 range.addr = (uintptr_t)host;
248 range.size = max_size;
249
250 trace_kvm_memcrypt_register_region(host, max_size);
251 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_REG_REGION, &range);
252 if (r) {
253 error_report("%s: failed to register region (%p+%#zx) error '%s'",
254 __func__, host, max_size, strerror(errno));
255 exit(1);
256 }
257 }
258
259 static void
sev_ram_block_removed(RAMBlockNotifier * n,void * host,size_t size,size_t max_size)260 sev_ram_block_removed(RAMBlockNotifier *n, void *host, size_t size,
261 size_t max_size)
262 {
263 int r;
264 struct kvm_enc_region range;
265 ram_addr_t offset;
266 MemoryRegion *mr;
267
268 /*
269 * The RAM device presents a memory region that should be treated
270 * as IO region and should not have been pinned.
271 */
272 mr = memory_region_from_host(host, &offset);
273 if (mr && memory_region_is_ram_device(mr)) {
274 return;
275 }
276
277 range.addr = (uintptr_t)host;
278 range.size = max_size;
279
280 trace_kvm_memcrypt_unregister_region(host, max_size);
281 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_UNREG_REGION, &range);
282 if (r) {
283 error_report("%s: failed to unregister region (%p+%#zx)",
284 __func__, host, max_size);
285 }
286 }
287
288 static struct RAMBlockNotifier sev_ram_notifier = {
289 .ram_block_added = sev_ram_block_added,
290 .ram_block_removed = sev_ram_block_removed,
291 };
292
293 static void
sev_guest_finalize(Object * obj)294 sev_guest_finalize(Object *obj)
295 {
296 }
297
298 static char *
sev_guest_get_session_file(Object * obj,Error ** errp)299 sev_guest_get_session_file(Object *obj, Error **errp)
300 {
301 SevGuestState *s = SEV_GUEST(obj);
302
303 return s->session_file ? g_strdup(s->session_file) : NULL;
304 }
305
306 static void
sev_guest_set_session_file(Object * obj,const char * value,Error ** errp)307 sev_guest_set_session_file(Object *obj, const char *value, Error **errp)
308 {
309 SevGuestState *s = SEV_GUEST(obj);
310
311 s->session_file = g_strdup(value);
312 }
313
314 static char *
sev_guest_get_dh_cert_file(Object * obj,Error ** errp)315 sev_guest_get_dh_cert_file(Object *obj, Error **errp)
316 {
317 SevGuestState *s = SEV_GUEST(obj);
318
319 return g_strdup(s->dh_cert_file);
320 }
321
322 static void
sev_guest_set_dh_cert_file(Object * obj,const char * value,Error ** errp)323 sev_guest_set_dh_cert_file(Object *obj, const char *value, Error **errp)
324 {
325 SevGuestState *s = SEV_GUEST(obj);
326
327 s->dh_cert_file = g_strdup(value);
328 }
329
330 static char *
sev_guest_get_sev_device(Object * obj,Error ** errp)331 sev_guest_get_sev_device(Object *obj, Error **errp)
332 {
333 SevGuestState *sev = SEV_GUEST(obj);
334
335 return g_strdup(sev->sev_device);
336 }
337
338 static void
sev_guest_set_sev_device(Object * obj,const char * value,Error ** errp)339 sev_guest_set_sev_device(Object *obj, const char *value, Error **errp)
340 {
341 SevGuestState *sev = SEV_GUEST(obj);
342
343 sev->sev_device = g_strdup(value);
344 }
345
sev_guest_get_kernel_hashes(Object * obj,Error ** errp)346 static bool sev_guest_get_kernel_hashes(Object *obj, Error **errp)
347 {
348 SevGuestState *sev = SEV_GUEST(obj);
349
350 return sev->kernel_hashes;
351 }
352
sev_guest_set_kernel_hashes(Object * obj,bool value,Error ** errp)353 static void sev_guest_set_kernel_hashes(Object *obj, bool value, Error **errp)
354 {
355 SevGuestState *sev = SEV_GUEST(obj);
356
357 sev->kernel_hashes = value;
358 }
359
sev_guest_get_legacy_vm_type(Object * obj,Error ** errp)360 static bool sev_guest_get_legacy_vm_type(Object *obj, Error **errp)
361 {
362 return SEV_GUEST(obj)->legacy_vm_type;
363 }
364
sev_guest_set_legacy_vm_type(Object * obj,bool value,Error ** errp)365 static void sev_guest_set_legacy_vm_type(Object *obj, bool value, Error **errp)
366 {
367 SEV_GUEST(obj)->legacy_vm_type = value;
368 }
369
370 bool
sev_enabled(void)371 sev_enabled(void)
372 {
373 return !!sev_guest;
374 }
375
376 bool
sev_es_enabled(void)377 sev_es_enabled(void)
378 {
379 return sev_enabled() && (sev_guest->policy & SEV_POLICY_ES);
380 }
381
382 uint32_t
sev_get_cbit_position(void)383 sev_get_cbit_position(void)
384 {
385 return sev_guest ? sev_guest->cbitpos : 0;
386 }
387
388 uint32_t
sev_get_reduced_phys_bits(void)389 sev_get_reduced_phys_bits(void)
390 {
391 return sev_guest ? sev_guest->reduced_phys_bits : 0;
392 }
393
sev_get_info(void)394 static SevInfo *sev_get_info(void)
395 {
396 SevInfo *info;
397
398 info = g_new0(SevInfo, 1);
399 info->enabled = sev_enabled();
400
401 if (info->enabled) {
402 info->api_major = sev_guest->api_major;
403 info->api_minor = sev_guest->api_minor;
404 info->build_id = sev_guest->build_id;
405 info->policy = sev_guest->policy;
406 info->state = sev_guest->state;
407 info->handle = sev_guest->handle;
408 }
409
410 return info;
411 }
412
qmp_query_sev(Error ** errp)413 SevInfo *qmp_query_sev(Error **errp)
414 {
415 SevInfo *info;
416
417 info = sev_get_info();
418 if (!info) {
419 error_setg(errp, "SEV feature is not available");
420 return NULL;
421 }
422
423 return info;
424 }
425
hmp_info_sev(Monitor * mon,const QDict * qdict)426 void hmp_info_sev(Monitor *mon, const QDict *qdict)
427 {
428 SevInfo *info = sev_get_info();
429
430 if (info && info->enabled) {
431 monitor_printf(mon, "handle: %d\n", info->handle);
432 monitor_printf(mon, "state: %s\n", SevState_str(info->state));
433 monitor_printf(mon, "build: %d\n", info->build_id);
434 monitor_printf(mon, "api version: %d.%d\n",
435 info->api_major, info->api_minor);
436 monitor_printf(mon, "debug: %s\n",
437 info->policy & SEV_POLICY_NODBG ? "off" : "on");
438 monitor_printf(mon, "key-sharing: %s\n",
439 info->policy & SEV_POLICY_NOKS ? "off" : "on");
440 } else {
441 monitor_printf(mon, "SEV is not enabled\n");
442 }
443
444 qapi_free_SevInfo(info);
445 }
446
447 static int
sev_get_pdh_info(int fd,guchar ** pdh,size_t * pdh_len,guchar ** cert_chain,size_t * cert_chain_len,Error ** errp)448 sev_get_pdh_info(int fd, guchar **pdh, size_t *pdh_len, guchar **cert_chain,
449 size_t *cert_chain_len, Error **errp)
450 {
451 guchar *pdh_data = NULL;
452 guchar *cert_chain_data = NULL;
453 struct sev_user_data_pdh_cert_export export = {};
454 int err, r;
455
456 /* query the certificate length */
457 r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err);
458 if (r < 0) {
459 if (err != SEV_RET_INVALID_LEN) {
460 error_setg(errp, "SEV: Failed to export PDH cert"
461 " ret=%d fw_err=%d (%s)",
462 r, err, fw_error_to_str(err));
463 return 1;
464 }
465 }
466
467 pdh_data = g_new(guchar, export.pdh_cert_len);
468 cert_chain_data = g_new(guchar, export.cert_chain_len);
469 export.pdh_cert_address = (unsigned long)pdh_data;
470 export.cert_chain_address = (unsigned long)cert_chain_data;
471
472 r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err);
473 if (r < 0) {
474 error_setg(errp, "SEV: Failed to export PDH cert ret=%d fw_err=%d (%s)",
475 r, err, fw_error_to_str(err));
476 goto e_free;
477 }
478
479 *pdh = pdh_data;
480 *pdh_len = export.pdh_cert_len;
481 *cert_chain = cert_chain_data;
482 *cert_chain_len = export.cert_chain_len;
483 return 0;
484
485 e_free:
486 g_free(pdh_data);
487 g_free(cert_chain_data);
488 return 1;
489 }
490
sev_get_cpu0_id(int fd,guchar ** id,size_t * id_len,Error ** errp)491 static int sev_get_cpu0_id(int fd, guchar **id, size_t *id_len, Error **errp)
492 {
493 guchar *id_data;
494 struct sev_user_data_get_id2 get_id2 = {};
495 int err, r;
496
497 /* query the ID length */
498 r = sev_platform_ioctl(fd, SEV_GET_ID2, &get_id2, &err);
499 if (r < 0 && err != SEV_RET_INVALID_LEN) {
500 error_setg(errp, "SEV: Failed to get ID ret=%d fw_err=%d (%s)",
501 r, err, fw_error_to_str(err));
502 return 1;
503 }
504
505 id_data = g_new(guchar, get_id2.length);
506 get_id2.address = (unsigned long)id_data;
507
508 r = sev_platform_ioctl(fd, SEV_GET_ID2, &get_id2, &err);
509 if (r < 0) {
510 error_setg(errp, "SEV: Failed to get ID ret=%d fw_err=%d (%s)",
511 r, err, fw_error_to_str(err));
512 goto err;
513 }
514
515 *id = id_data;
516 *id_len = get_id2.length;
517 return 0;
518
519 err:
520 g_free(id_data);
521 return 1;
522 }
523
sev_get_capabilities(Error ** errp)524 static SevCapability *sev_get_capabilities(Error **errp)
525 {
526 SevCapability *cap = NULL;
527 guchar *pdh_data = NULL;
528 guchar *cert_chain_data = NULL;
529 guchar *cpu0_id_data = NULL;
530 size_t pdh_len = 0, cert_chain_len = 0, cpu0_id_len = 0;
531 uint32_t ebx;
532 int fd;
533
534 if (!kvm_enabled()) {
535 error_setg(errp, "KVM not enabled");
536 return NULL;
537 }
538 if (kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, NULL) < 0) {
539 error_setg(errp, "SEV is not enabled in KVM");
540 return NULL;
541 }
542
543 fd = open(DEFAULT_SEV_DEVICE, O_RDWR);
544 if (fd < 0) {
545 error_setg_errno(errp, errno, "SEV: Failed to open %s",
546 DEFAULT_SEV_DEVICE);
547 return NULL;
548 }
549
550 if (sev_get_pdh_info(fd, &pdh_data, &pdh_len,
551 &cert_chain_data, &cert_chain_len, errp)) {
552 goto out;
553 }
554
555 if (sev_get_cpu0_id(fd, &cpu0_id_data, &cpu0_id_len, errp)) {
556 goto out;
557 }
558
559 cap = g_new0(SevCapability, 1);
560 cap->pdh = g_base64_encode(pdh_data, pdh_len);
561 cap->cert_chain = g_base64_encode(cert_chain_data, cert_chain_len);
562 cap->cpu0_id = g_base64_encode(cpu0_id_data, cpu0_id_len);
563
564 host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL);
565 cap->cbitpos = ebx & 0x3f;
566
567 /*
568 * When SEV feature is enabled, we loose one bit in guest physical
569 * addressing.
570 */
571 cap->reduced_phys_bits = 1;
572
573 out:
574 g_free(cpu0_id_data);
575 g_free(pdh_data);
576 g_free(cert_chain_data);
577 close(fd);
578 return cap;
579 }
580
qmp_query_sev_capabilities(Error ** errp)581 SevCapability *qmp_query_sev_capabilities(Error **errp)
582 {
583 return sev_get_capabilities(errp);
584 }
585
sev_get_attestation_report(const char * mnonce,Error ** errp)586 static SevAttestationReport *sev_get_attestation_report(const char *mnonce,
587 Error **errp)
588 {
589 struct kvm_sev_attestation_report input = {};
590 SevAttestationReport *report = NULL;
591 SevGuestState *sev = sev_guest;
592 g_autofree guchar *data = NULL;
593 g_autofree guchar *buf = NULL;
594 gsize len;
595 int err = 0, ret;
596
597 if (!sev_enabled()) {
598 error_setg(errp, "SEV is not enabled");
599 return NULL;
600 }
601
602 /* lets decode the mnonce string */
603 buf = g_base64_decode(mnonce, &len);
604 if (!buf) {
605 error_setg(errp, "SEV: failed to decode mnonce input");
606 return NULL;
607 }
608
609 /* verify the input mnonce length */
610 if (len != sizeof(input.mnonce)) {
611 error_setg(errp, "SEV: mnonce must be %zu bytes (got %" G_GSIZE_FORMAT ")",
612 sizeof(input.mnonce), len);
613 return NULL;
614 }
615
616 /* Query the report length */
617 ret = sev_ioctl(sev->sev_fd, KVM_SEV_GET_ATTESTATION_REPORT,
618 &input, &err);
619 if (ret < 0) {
620 if (err != SEV_RET_INVALID_LEN) {
621 error_setg(errp, "SEV: Failed to query the attestation report"
622 " length ret=%d fw_err=%d (%s)",
623 ret, err, fw_error_to_str(err));
624 return NULL;
625 }
626 }
627
628 data = g_malloc(input.len);
629 input.uaddr = (unsigned long)data;
630 memcpy(input.mnonce, buf, sizeof(input.mnonce));
631
632 /* Query the report */
633 ret = sev_ioctl(sev->sev_fd, KVM_SEV_GET_ATTESTATION_REPORT,
634 &input, &err);
635 if (ret) {
636 error_setg_errno(errp, errno, "SEV: Failed to get attestation report"
637 " ret=%d fw_err=%d (%s)", ret, err, fw_error_to_str(err));
638 return NULL;
639 }
640
641 report = g_new0(SevAttestationReport, 1);
642 report->data = g_base64_encode(data, input.len);
643
644 trace_kvm_sev_attestation_report(mnonce, report->data);
645
646 return report;
647 }
648
qmp_query_sev_attestation_report(const char * mnonce,Error ** errp)649 SevAttestationReport *qmp_query_sev_attestation_report(const char *mnonce,
650 Error **errp)
651 {
652 return sev_get_attestation_report(mnonce, errp);
653 }
654
655 static int
sev_read_file_base64(const char * filename,guchar ** data,gsize * len)656 sev_read_file_base64(const char *filename, guchar **data, gsize *len)
657 {
658 gsize sz;
659 g_autofree gchar *base64 = NULL;
660 GError *error = NULL;
661
662 if (!g_file_get_contents(filename, &base64, &sz, &error)) {
663 error_report("SEV: Failed to read '%s' (%s)", filename, error->message);
664 g_error_free(error);
665 return -1;
666 }
667
668 *data = g_base64_decode(base64, len);
669 return 0;
670 }
671
672 static int
sev_launch_start(SevGuestState * sev)673 sev_launch_start(SevGuestState *sev)
674 {
675 gsize sz;
676 int ret = 1;
677 int fw_error, rc;
678 struct kvm_sev_launch_start start = {
679 .handle = sev->handle, .policy = sev->policy
680 };
681 guchar *session = NULL, *dh_cert = NULL;
682
683 if (sev->session_file) {
684 if (sev_read_file_base64(sev->session_file, &session, &sz) < 0) {
685 goto out;
686 }
687 start.session_uaddr = (unsigned long)session;
688 start.session_len = sz;
689 }
690
691 if (sev->dh_cert_file) {
692 if (sev_read_file_base64(sev->dh_cert_file, &dh_cert, &sz) < 0) {
693 goto out;
694 }
695 start.dh_uaddr = (unsigned long)dh_cert;
696 start.dh_len = sz;
697 }
698
699 trace_kvm_sev_launch_start(start.policy, session, dh_cert);
700 rc = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_START, &start, &fw_error);
701 if (rc < 0) {
702 error_report("%s: LAUNCH_START ret=%d fw_error=%d '%s'",
703 __func__, ret, fw_error, fw_error_to_str(fw_error));
704 goto out;
705 }
706
707 sev_set_guest_state(sev, SEV_STATE_LAUNCH_UPDATE);
708 sev->handle = start.handle;
709 ret = 0;
710
711 out:
712 g_free(session);
713 g_free(dh_cert);
714 return ret;
715 }
716
717 static int
sev_launch_update_data(SevGuestState * sev,uint8_t * addr,uint64_t len)718 sev_launch_update_data(SevGuestState *sev, uint8_t *addr, uint64_t len)
719 {
720 int ret, fw_error;
721 struct kvm_sev_launch_update_data update;
722
723 if (!addr || !len) {
724 return 1;
725 }
726
727 update.uaddr = (uintptr_t)addr;
728 update.len = len;
729 trace_kvm_sev_launch_update_data(addr, len);
730 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_UPDATE_DATA,
731 &update, &fw_error);
732 if (ret) {
733 error_report("%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'",
734 __func__, ret, fw_error, fw_error_to_str(fw_error));
735 }
736
737 return ret;
738 }
739
740 static int
sev_launch_update_vmsa(SevGuestState * sev)741 sev_launch_update_vmsa(SevGuestState *sev)
742 {
743 int ret, fw_error;
744
745 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_UPDATE_VMSA, NULL, &fw_error);
746 if (ret) {
747 error_report("%s: LAUNCH_UPDATE_VMSA ret=%d fw_error=%d '%s'",
748 __func__, ret, fw_error, fw_error_to_str(fw_error));
749 }
750
751 return ret;
752 }
753
754 static void
sev_launch_get_measure(Notifier * notifier,void * unused)755 sev_launch_get_measure(Notifier *notifier, void *unused)
756 {
757 SevGuestState *sev = sev_guest;
758 int ret, error;
759 g_autofree guchar *data = NULL;
760 struct kvm_sev_launch_measure measurement = {};
761
762 if (!sev_check_state(sev, SEV_STATE_LAUNCH_UPDATE)) {
763 return;
764 }
765
766 if (sev_es_enabled()) {
767 /* measure all the VM save areas before getting launch_measure */
768 ret = sev_launch_update_vmsa(sev);
769 if (ret) {
770 exit(1);
771 }
772 kvm_mark_guest_state_protected();
773 }
774
775 /* query the measurement blob length */
776 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_MEASURE,
777 &measurement, &error);
778 if (!measurement.len) {
779 error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'",
780 __func__, ret, error, fw_error_to_str(errno));
781 return;
782 }
783
784 data = g_new0(guchar, measurement.len);
785 measurement.uaddr = (unsigned long)data;
786
787 /* get the measurement blob */
788 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_MEASURE,
789 &measurement, &error);
790 if (ret) {
791 error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'",
792 __func__, ret, error, fw_error_to_str(errno));
793 return;
794 }
795
796 sev_set_guest_state(sev, SEV_STATE_LAUNCH_SECRET);
797
798 /* encode the measurement value and emit the event */
799 sev->measurement = g_base64_encode(data, measurement.len);
800 trace_kvm_sev_launch_measurement(sev->measurement);
801 }
802
sev_get_launch_measurement(void)803 static char *sev_get_launch_measurement(void)
804 {
805 if (sev_guest &&
806 sev_guest->state >= SEV_STATE_LAUNCH_SECRET) {
807 return g_strdup(sev_guest->measurement);
808 }
809
810 return NULL;
811 }
812
qmp_query_sev_launch_measure(Error ** errp)813 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
814 {
815 char *data;
816 SevLaunchMeasureInfo *info;
817
818 data = sev_get_launch_measurement();
819 if (!data) {
820 error_setg(errp, "SEV launch measurement is not available");
821 return NULL;
822 }
823
824 info = g_malloc0(sizeof(*info));
825 info->data = data;
826
827 return info;
828 }
829
830 static Notifier sev_machine_done_notify = {
831 .notify = sev_launch_get_measure,
832 };
833
834 static void
sev_launch_finish(SevGuestState * sev)835 sev_launch_finish(SevGuestState *sev)
836 {
837 int ret, error;
838
839 trace_kvm_sev_launch_finish();
840 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_FINISH, 0, &error);
841 if (ret) {
842 error_report("%s: LAUNCH_FINISH ret=%d fw_error=%d '%s'",
843 __func__, ret, error, fw_error_to_str(error));
844 exit(1);
845 }
846
847 sev_set_guest_state(sev, SEV_STATE_RUNNING);
848
849 /* add migration blocker */
850 error_setg(&sev_mig_blocker,
851 "SEV: Migration is not implemented");
852 migrate_add_blocker(&sev_mig_blocker, &error_fatal);
853 }
854
855 static void
sev_vm_state_change(void * opaque,bool running,RunState state)856 sev_vm_state_change(void *opaque, bool running, RunState state)
857 {
858 SevGuestState *sev = opaque;
859
860 if (running) {
861 if (!sev_check_state(sev, SEV_STATE_RUNNING)) {
862 sev_launch_finish(sev);
863 }
864 }
865 }
866
sev_kvm_type(X86ConfidentialGuest * cg)867 static int sev_kvm_type(X86ConfidentialGuest *cg)
868 {
869 SevGuestState *sev = SEV_GUEST(cg);
870 int kvm_type;
871
872 if (sev->kvm_type != -1) {
873 goto out;
874 }
875
876 kvm_type = (sev->policy & SEV_POLICY_ES) ? KVM_X86_SEV_ES_VM : KVM_X86_SEV_VM;
877 if (kvm_is_vm_type_supported(kvm_type) && !sev->legacy_vm_type) {
878 sev->kvm_type = kvm_type;
879 } else {
880 sev->kvm_type = KVM_X86_DEFAULT_VM;
881 }
882
883 out:
884 return sev->kvm_type;
885 }
886
sev_kvm_init(ConfidentialGuestSupport * cgs,Error ** errp)887 static int sev_kvm_init(ConfidentialGuestSupport *cgs, Error **errp)
888 {
889 SevGuestState *sev = SEV_GUEST(cgs);
890 char *devname;
891 int ret, fw_error, cmd;
892 uint32_t ebx;
893 uint32_t host_cbitpos;
894 struct sev_user_data_status status = {};
895
896 ret = ram_block_discard_disable(true);
897 if (ret) {
898 error_report("%s: cannot disable RAM discard", __func__);
899 return -1;
900 }
901
902 sev_guest = sev;
903 sev->state = SEV_STATE_UNINIT;
904
905 host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL);
906 host_cbitpos = ebx & 0x3f;
907
908 /*
909 * The cbitpos value will be placed in bit positions 5:0 of the EBX
910 * register of CPUID 0x8000001F. No need to verify the range as the
911 * comparison against the host value accomplishes that.
912 */
913 if (host_cbitpos != sev->cbitpos) {
914 error_setg(errp, "%s: cbitpos check failed, host '%d' requested '%d'",
915 __func__, host_cbitpos, sev->cbitpos);
916 goto err;
917 }
918
919 /*
920 * The reduced-phys-bits value will be placed in bit positions 11:6 of
921 * the EBX register of CPUID 0x8000001F, so verify the supplied value
922 * is in the range of 1 to 63.
923 */
924 if (sev->reduced_phys_bits < 1 || sev->reduced_phys_bits > 63) {
925 error_setg(errp, "%s: reduced_phys_bits check failed,"
926 " it should be in the range of 1 to 63, requested '%d'",
927 __func__, sev->reduced_phys_bits);
928 goto err;
929 }
930
931 devname = object_property_get_str(OBJECT(sev), "sev-device", NULL);
932 sev->sev_fd = open(devname, O_RDWR);
933 if (sev->sev_fd < 0) {
934 error_setg(errp, "%s: Failed to open %s '%s'", __func__,
935 devname, strerror(errno));
936 g_free(devname);
937 goto err;
938 }
939 g_free(devname);
940
941 ret = sev_platform_ioctl(sev->sev_fd, SEV_PLATFORM_STATUS, &status,
942 &fw_error);
943 if (ret) {
944 error_setg(errp, "%s: failed to get platform status ret=%d "
945 "fw_error='%d: %s'", __func__, ret, fw_error,
946 fw_error_to_str(fw_error));
947 goto err;
948 }
949 sev->build_id = status.build;
950 sev->api_major = status.api_major;
951 sev->api_minor = status.api_minor;
952
953 if (sev_es_enabled()) {
954 if (!kvm_kernel_irqchip_allowed()) {
955 error_report("%s: SEV-ES guests require in-kernel irqchip support",
956 __func__);
957 goto err;
958 }
959
960 if (!(status.flags & SEV_STATUS_FLAGS_CONFIG_ES)) {
961 error_report("%s: guest policy requires SEV-ES, but "
962 "host SEV-ES support unavailable",
963 __func__);
964 goto err;
965 }
966 }
967
968 trace_kvm_sev_init();
969 if (sev_kvm_type(X86_CONFIDENTIAL_GUEST(sev)) == KVM_X86_DEFAULT_VM) {
970 cmd = sev_es_enabled() ? KVM_SEV_ES_INIT : KVM_SEV_INIT;
971
972 ret = sev_ioctl(sev->sev_fd, cmd, NULL, &fw_error);
973 } else {
974 struct kvm_sev_init args = { 0 };
975
976 ret = sev_ioctl(sev->sev_fd, KVM_SEV_INIT2, &args, &fw_error);
977 }
978
979 if (ret) {
980 error_setg(errp, "%s: failed to initialize ret=%d fw_error=%d '%s'",
981 __func__, ret, fw_error, fw_error_to_str(fw_error));
982 goto err;
983 }
984
985 ret = sev_launch_start(sev);
986 if (ret) {
987 error_setg(errp, "%s: failed to create encryption context", __func__);
988 goto err;
989 }
990
991 ram_block_notifier_add(&sev_ram_notifier);
992 qemu_add_machine_init_done_notifier(&sev_machine_done_notify);
993 qemu_add_vm_change_state_handler(sev_vm_state_change, sev);
994
995 cgs->ready = true;
996
997 return 0;
998 err:
999 sev_guest = NULL;
1000 ram_block_discard_disable(false);
1001 return -1;
1002 }
1003
1004 int
sev_encrypt_flash(uint8_t * ptr,uint64_t len,Error ** errp)1005 sev_encrypt_flash(uint8_t *ptr, uint64_t len, Error **errp)
1006 {
1007 if (!sev_guest) {
1008 return 0;
1009 }
1010
1011 /* if SEV is in update state then encrypt the data else do nothing */
1012 if (sev_check_state(sev_guest, SEV_STATE_LAUNCH_UPDATE)) {
1013 int ret = sev_launch_update_data(sev_guest, ptr, len);
1014 if (ret < 0) {
1015 error_setg(errp, "SEV: Failed to encrypt pflash rom");
1016 return ret;
1017 }
1018 }
1019
1020 return 0;
1021 }
1022
sev_inject_launch_secret(const char * packet_hdr,const char * secret,uint64_t gpa,Error ** errp)1023 int sev_inject_launch_secret(const char *packet_hdr, const char *secret,
1024 uint64_t gpa, Error **errp)
1025 {
1026 ERRP_GUARD();
1027 struct kvm_sev_launch_secret input;
1028 g_autofree guchar *data = NULL, *hdr = NULL;
1029 int error, ret = 1;
1030 void *hva;
1031 gsize hdr_sz = 0, data_sz = 0;
1032 MemoryRegion *mr = NULL;
1033
1034 if (!sev_guest) {
1035 error_setg(errp, "SEV not enabled for guest");
1036 return 1;
1037 }
1038
1039 /* secret can be injected only in this state */
1040 if (!sev_check_state(sev_guest, SEV_STATE_LAUNCH_SECRET)) {
1041 error_setg(errp, "SEV: Not in correct state. (LSECRET) %x",
1042 sev_guest->state);
1043 return 1;
1044 }
1045
1046 hdr = g_base64_decode(packet_hdr, &hdr_sz);
1047 if (!hdr || !hdr_sz) {
1048 error_setg(errp, "SEV: Failed to decode sequence header");
1049 return 1;
1050 }
1051
1052 data = g_base64_decode(secret, &data_sz);
1053 if (!data || !data_sz) {
1054 error_setg(errp, "SEV: Failed to decode data");
1055 return 1;
1056 }
1057
1058 hva = gpa2hva(&mr, gpa, data_sz, errp);
1059 if (!hva) {
1060 error_prepend(errp, "SEV: Failed to calculate guest address: ");
1061 return 1;
1062 }
1063
1064 input.hdr_uaddr = (uint64_t)(unsigned long)hdr;
1065 input.hdr_len = hdr_sz;
1066
1067 input.trans_uaddr = (uint64_t)(unsigned long)data;
1068 input.trans_len = data_sz;
1069
1070 input.guest_uaddr = (uint64_t)(unsigned long)hva;
1071 input.guest_len = data_sz;
1072
1073 trace_kvm_sev_launch_secret(gpa, input.guest_uaddr,
1074 input.trans_uaddr, input.trans_len);
1075
1076 ret = sev_ioctl(sev_guest->sev_fd, KVM_SEV_LAUNCH_SECRET,
1077 &input, &error);
1078 if (ret) {
1079 error_setg(errp, "SEV: failed to inject secret ret=%d fw_error=%d '%s'",
1080 ret, error, fw_error_to_str(error));
1081 return ret;
1082 }
1083
1084 return 0;
1085 }
1086
1087 #define SEV_SECRET_GUID "4c2eb361-7d9b-4cc3-8081-127c90d3d294"
1088 struct sev_secret_area {
1089 uint32_t base;
1090 uint32_t size;
1091 };
1092
qmp_sev_inject_launch_secret(const char * packet_hdr,const char * secret,bool has_gpa,uint64_t gpa,Error ** errp)1093 void qmp_sev_inject_launch_secret(const char *packet_hdr,
1094 const char *secret,
1095 bool has_gpa, uint64_t gpa,
1096 Error **errp)
1097 {
1098 if (!sev_enabled()) {
1099 error_setg(errp, "SEV not enabled for guest");
1100 return;
1101 }
1102 if (!has_gpa) {
1103 uint8_t *data;
1104 struct sev_secret_area *area;
1105
1106 if (!pc_system_ovmf_table_find(SEV_SECRET_GUID, &data, NULL)) {
1107 error_setg(errp, "SEV: no secret area found in OVMF,"
1108 " gpa must be specified.");
1109 return;
1110 }
1111 area = (struct sev_secret_area *)data;
1112 gpa = area->base;
1113 }
1114
1115 sev_inject_launch_secret(packet_hdr, secret, gpa, errp);
1116 }
1117
1118 static int
sev_es_parse_reset_block(SevInfoBlock * info,uint32_t * addr)1119 sev_es_parse_reset_block(SevInfoBlock *info, uint32_t *addr)
1120 {
1121 if (!info->reset_addr) {
1122 error_report("SEV-ES reset address is zero");
1123 return 1;
1124 }
1125
1126 *addr = info->reset_addr;
1127
1128 return 0;
1129 }
1130
1131 static int
sev_es_find_reset_vector(void * flash_ptr,uint64_t flash_size,uint32_t * addr)1132 sev_es_find_reset_vector(void *flash_ptr, uint64_t flash_size,
1133 uint32_t *addr)
1134 {
1135 QemuUUID info_guid, *guid;
1136 SevInfoBlock *info;
1137 uint8_t *data;
1138 uint16_t *len;
1139
1140 /*
1141 * Initialize the address to zero. An address of zero with a successful
1142 * return code indicates that SEV-ES is not active.
1143 */
1144 *addr = 0;
1145
1146 /*
1147 * Extract the AP reset vector for SEV-ES guests by locating the SEV GUID.
1148 * The SEV GUID is located on its own (original implementation) or within
1149 * the Firmware GUID Table (new implementation), either of which are
1150 * located 32 bytes from the end of the flash.
1151 *
1152 * Check the Firmware GUID Table first.
1153 */
1154 if (pc_system_ovmf_table_find(SEV_INFO_BLOCK_GUID, &data, NULL)) {
1155 return sev_es_parse_reset_block((SevInfoBlock *)data, addr);
1156 }
1157
1158 /*
1159 * SEV info block not found in the Firmware GUID Table (or there isn't
1160 * a Firmware GUID Table), fall back to the original implementation.
1161 */
1162 data = flash_ptr + flash_size - 0x20;
1163
1164 qemu_uuid_parse(SEV_INFO_BLOCK_GUID, &info_guid);
1165 info_guid = qemu_uuid_bswap(info_guid); /* GUIDs are LE */
1166
1167 guid = (QemuUUID *)(data - sizeof(info_guid));
1168 if (!qemu_uuid_is_equal(guid, &info_guid)) {
1169 error_report("SEV information block/Firmware GUID Table block not found in pflash rom");
1170 return 1;
1171 }
1172
1173 len = (uint16_t *)((uint8_t *)guid - sizeof(*len));
1174 info = (SevInfoBlock *)(data - le16_to_cpu(*len));
1175
1176 return sev_es_parse_reset_block(info, addr);
1177 }
1178
sev_es_set_reset_vector(CPUState * cpu)1179 void sev_es_set_reset_vector(CPUState *cpu)
1180 {
1181 X86CPU *x86;
1182 CPUX86State *env;
1183
1184 /* Only update if we have valid reset information */
1185 if (!sev_guest || !sev_guest->reset_data_valid) {
1186 return;
1187 }
1188
1189 /* Do not update the BSP reset state */
1190 if (cpu->cpu_index == 0) {
1191 return;
1192 }
1193
1194 x86 = X86_CPU(cpu);
1195 env = &x86->env;
1196
1197 cpu_x86_load_seg_cache(env, R_CS, 0xf000, sev_guest->reset_cs, 0xffff,
1198 DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |
1199 DESC_R_MASK | DESC_A_MASK);
1200
1201 env->eip = sev_guest->reset_ip;
1202 }
1203
sev_es_save_reset_vector(void * flash_ptr,uint64_t flash_size)1204 int sev_es_save_reset_vector(void *flash_ptr, uint64_t flash_size)
1205 {
1206 CPUState *cpu;
1207 uint32_t addr;
1208 int ret;
1209
1210 if (!sev_es_enabled()) {
1211 return 0;
1212 }
1213
1214 addr = 0;
1215 ret = sev_es_find_reset_vector(flash_ptr, flash_size,
1216 &addr);
1217 if (ret) {
1218 return ret;
1219 }
1220
1221 if (addr) {
1222 sev_guest->reset_cs = addr & 0xffff0000;
1223 sev_guest->reset_ip = addr & 0x0000ffff;
1224 sev_guest->reset_data_valid = true;
1225
1226 CPU_FOREACH(cpu) {
1227 sev_es_set_reset_vector(cpu);
1228 }
1229 }
1230
1231 return 0;
1232 }
1233
1234 static const QemuUUID sev_hash_table_header_guid = {
1235 .data = UUID_LE(0x9438d606, 0x4f22, 0x4cc9, 0xb4, 0x79, 0xa7, 0x93,
1236 0xd4, 0x11, 0xfd, 0x21)
1237 };
1238
1239 static const QemuUUID sev_kernel_entry_guid = {
1240 .data = UUID_LE(0x4de79437, 0xabd2, 0x427f, 0xb8, 0x35, 0xd5, 0xb1,
1241 0x72, 0xd2, 0x04, 0x5b)
1242 };
1243 static const QemuUUID sev_initrd_entry_guid = {
1244 .data = UUID_LE(0x44baf731, 0x3a2f, 0x4bd7, 0x9a, 0xf1, 0x41, 0xe2,
1245 0x91, 0x69, 0x78, 0x1d)
1246 };
1247 static const QemuUUID sev_cmdline_entry_guid = {
1248 .data = UUID_LE(0x97d02dd8, 0xbd20, 0x4c94, 0xaa, 0x78, 0xe7, 0x71,
1249 0x4d, 0x36, 0xab, 0x2a)
1250 };
1251
1252 /*
1253 * Add the hashes of the linux kernel/initrd/cmdline to an encrypted guest page
1254 * which is included in SEV's initial memory measurement.
1255 */
sev_add_kernel_loader_hashes(SevKernelLoaderContext * ctx,Error ** errp)1256 bool sev_add_kernel_loader_hashes(SevKernelLoaderContext *ctx, Error **errp)
1257 {
1258 uint8_t *data;
1259 SevHashTableDescriptor *area;
1260 SevHashTable *ht;
1261 PaddedSevHashTable *padded_ht;
1262 uint8_t cmdline_hash[HASH_SIZE];
1263 uint8_t initrd_hash[HASH_SIZE];
1264 uint8_t kernel_hash[HASH_SIZE];
1265 uint8_t *hashp;
1266 size_t hash_len = HASH_SIZE;
1267 hwaddr mapped_len = sizeof(*padded_ht);
1268 MemTxAttrs attrs = { 0 };
1269 bool ret = true;
1270
1271 /*
1272 * Only add the kernel hashes if the sev-guest configuration explicitly
1273 * stated kernel-hashes=on.
1274 */
1275 if (!sev_guest->kernel_hashes) {
1276 return false;
1277 }
1278
1279 if (!pc_system_ovmf_table_find(SEV_HASH_TABLE_RV_GUID, &data, NULL)) {
1280 error_setg(errp, "SEV: kernel specified but guest firmware "
1281 "has no hashes table GUID");
1282 return false;
1283 }
1284 area = (SevHashTableDescriptor *)data;
1285 if (!area->base || area->size < sizeof(PaddedSevHashTable)) {
1286 error_setg(errp, "SEV: guest firmware hashes table area is invalid "
1287 "(base=0x%x size=0x%x)", area->base, area->size);
1288 return false;
1289 }
1290
1291 /*
1292 * Calculate hash of kernel command-line with the terminating null byte. If
1293 * the user doesn't supply a command-line via -append, the 1-byte "\0" will
1294 * be used.
1295 */
1296 hashp = cmdline_hash;
1297 if (qcrypto_hash_bytes(QCRYPTO_HASH_ALG_SHA256, ctx->cmdline_data,
1298 ctx->cmdline_size, &hashp, &hash_len, errp) < 0) {
1299 return false;
1300 }
1301 assert(hash_len == HASH_SIZE);
1302
1303 /*
1304 * Calculate hash of initrd. If the user doesn't supply an initrd via
1305 * -initrd, an empty buffer will be used (ctx->initrd_size == 0).
1306 */
1307 hashp = initrd_hash;
1308 if (qcrypto_hash_bytes(QCRYPTO_HASH_ALG_SHA256, ctx->initrd_data,
1309 ctx->initrd_size, &hashp, &hash_len, errp) < 0) {
1310 return false;
1311 }
1312 assert(hash_len == HASH_SIZE);
1313
1314 /* Calculate hash of the kernel */
1315 hashp = kernel_hash;
1316 struct iovec iov[2] = {
1317 { .iov_base = ctx->setup_data, .iov_len = ctx->setup_size },
1318 { .iov_base = ctx->kernel_data, .iov_len = ctx->kernel_size }
1319 };
1320 if (qcrypto_hash_bytesv(QCRYPTO_HASH_ALG_SHA256, iov, ARRAY_SIZE(iov),
1321 &hashp, &hash_len, errp) < 0) {
1322 return false;
1323 }
1324 assert(hash_len == HASH_SIZE);
1325
1326 /*
1327 * Populate the hashes table in the guest's memory at the OVMF-designated
1328 * area for the SEV hashes table
1329 */
1330 padded_ht = address_space_map(&address_space_memory, area->base,
1331 &mapped_len, true, attrs);
1332 if (!padded_ht || mapped_len != sizeof(*padded_ht)) {
1333 error_setg(errp, "SEV: cannot map hashes table guest memory area");
1334 return false;
1335 }
1336 ht = &padded_ht->ht;
1337
1338 ht->guid = sev_hash_table_header_guid;
1339 ht->len = sizeof(*ht);
1340
1341 ht->cmdline.guid = sev_cmdline_entry_guid;
1342 ht->cmdline.len = sizeof(ht->cmdline);
1343 memcpy(ht->cmdline.hash, cmdline_hash, sizeof(ht->cmdline.hash));
1344
1345 ht->initrd.guid = sev_initrd_entry_guid;
1346 ht->initrd.len = sizeof(ht->initrd);
1347 memcpy(ht->initrd.hash, initrd_hash, sizeof(ht->initrd.hash));
1348
1349 ht->kernel.guid = sev_kernel_entry_guid;
1350 ht->kernel.len = sizeof(ht->kernel);
1351 memcpy(ht->kernel.hash, kernel_hash, sizeof(ht->kernel.hash));
1352
1353 /* zero the excess data so the measurement can be reliably calculated */
1354 memset(padded_ht->padding, 0, sizeof(padded_ht->padding));
1355
1356 if (sev_encrypt_flash((uint8_t *)padded_ht, sizeof(*padded_ht), errp) < 0) {
1357 ret = false;
1358 }
1359
1360 address_space_unmap(&address_space_memory, padded_ht,
1361 mapped_len, true, mapped_len);
1362
1363 return ret;
1364 }
1365
1366 static void
sev_guest_class_init(ObjectClass * oc,void * data)1367 sev_guest_class_init(ObjectClass *oc, void *data)
1368 {
1369 ConfidentialGuestSupportClass *klass = CONFIDENTIAL_GUEST_SUPPORT_CLASS(oc);
1370 X86ConfidentialGuestClass *x86_klass = X86_CONFIDENTIAL_GUEST_CLASS(oc);
1371
1372 klass->kvm_init = sev_kvm_init;
1373 x86_klass->kvm_type = sev_kvm_type;
1374
1375 object_class_property_add_str(oc, "sev-device",
1376 sev_guest_get_sev_device,
1377 sev_guest_set_sev_device);
1378 object_class_property_set_description(oc, "sev-device",
1379 "SEV device to use");
1380 object_class_property_add_str(oc, "dh-cert-file",
1381 sev_guest_get_dh_cert_file,
1382 sev_guest_set_dh_cert_file);
1383 object_class_property_set_description(oc, "dh-cert-file",
1384 "guest owners DH certificate (encoded with base64)");
1385 object_class_property_add_str(oc, "session-file",
1386 sev_guest_get_session_file,
1387 sev_guest_set_session_file);
1388 object_class_property_set_description(oc, "session-file",
1389 "guest owners session parameters (encoded with base64)");
1390 object_class_property_add_bool(oc, "kernel-hashes",
1391 sev_guest_get_kernel_hashes,
1392 sev_guest_set_kernel_hashes);
1393 object_class_property_set_description(oc, "kernel-hashes",
1394 "add kernel hashes to guest firmware for measured Linux boot");
1395 object_class_property_add_bool(oc, "legacy-vm-type",
1396 sev_guest_get_legacy_vm_type,
1397 sev_guest_set_legacy_vm_type);
1398 object_class_property_set_description(oc, "legacy-vm-type",
1399 "use legacy VM type to maintain measurement compatibility with older QEMU or kernel versions.");
1400 }
1401
1402 static void
sev_guest_instance_init(Object * obj)1403 sev_guest_instance_init(Object *obj)
1404 {
1405 SevGuestState *sev = SEV_GUEST(obj);
1406
1407 sev->kvm_type = -1;
1408
1409 sev->sev_device = g_strdup(DEFAULT_SEV_DEVICE);
1410 sev->policy = DEFAULT_GUEST_POLICY;
1411 object_property_add_uint32_ptr(obj, "policy", &sev->policy,
1412 OBJ_PROP_FLAG_READWRITE);
1413 object_property_add_uint32_ptr(obj, "handle", &sev->handle,
1414 OBJ_PROP_FLAG_READWRITE);
1415 object_property_add_uint32_ptr(obj, "cbitpos", &sev->cbitpos,
1416 OBJ_PROP_FLAG_READWRITE);
1417 object_property_add_uint32_ptr(obj, "reduced-phys-bits",
1418 &sev->reduced_phys_bits,
1419 OBJ_PROP_FLAG_READWRITE);
1420 object_apply_compat_props(obj);
1421 }
1422
1423 /* sev guest info */
1424 static const TypeInfo sev_guest_info = {
1425 .parent = TYPE_X86_CONFIDENTIAL_GUEST,
1426 .name = TYPE_SEV_GUEST,
1427 .instance_size = sizeof(SevGuestState),
1428 .instance_finalize = sev_guest_finalize,
1429 .class_init = sev_guest_class_init,
1430 .instance_init = sev_guest_instance_init,
1431 .interfaces = (InterfaceInfo[]) {
1432 { TYPE_USER_CREATABLE },
1433 { }
1434 }
1435 };
1436
1437 static void
sev_register_types(void)1438 sev_register_types(void)
1439 {
1440 type_register_static(&sev_guest_info);
1441 }
1442
1443 type_init(sev_register_types);
1444