SEV: QMP support for Inject-Launch-Secret
PATCH v2 1/1 SEV: QMP support for Inject-Launch-Secret
From: Tobin Feldman-Fitzthum <[email protected]>
AMD SEV allows a guest owner to inject a secret blob into the memory of a virtual machine. The secret is encrypted with the SEV Transport Encryption Key and integrity is guaranteed with the Transport Integrity Key. Although QEMU faciliates the injection of the launch secret, it cannot access the secret.
--- include/monitor/monitor.h | 3 ++ include/sysemu/sev.h | 2 ++ monitor/misc.c | 8 ++--- qapi/misc-target.json | 18 +++++++++++ target/i386/monitor.c | 9 ++++++ target/i386/sev-stub.c | 5 +++ target/i386/sev.c | 66 +++++++++++++++++++++++++++++++++++++++ target/i386/sev_i386.h | 3 ++ target/i386/trace-events | 1 + 9 files changed, 111 insertions(+), 4 deletions(-)
include/monitor/monitor.h +3 -0
@@ -4,6 +4,7 @@#include "block/block.h" #include "qapi/qapi-types-misc.h" #include "qemu/readline.h" +#include "include/exec/hwaddr.h" extern __threadMonitor *cur_mon;typedef struct MonitorHMP MonitorHMP ;
@@ -36,6 +37,8 @@ void monitor_flush(Monitor *mon);int monitor_set_cpu (int cpu_index);int monitor_get_cpu_index (void ); +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp); +void monitor_read_command (MonitorHMP *mon,int show_prompt);int monitor_read_password (MonitorHMP *mon,ReadLineFunc *readline_func,void *opaque);
include/sysemu/sev.h +2 -0
@@ -18,4 +18,6 @@void *sev_guest_init (const char *id);int sev_encrypt_data (void *handle,uint8_t *ptr,uint64_t len); +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa);#endif
monitor/misc.c +4 -4
@@ -674,10 +674,10 @@ static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)memory_dump (mon, count, format, size, addr,1 ); } -static void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,Error **errp) +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp) {MemoryRegionSection mrs =memory_region_find (get_system_memory (), - addr,1 ); + addr, size);if (!mrs.mr) {error_setg (errp,"No memory is mapped at address 0x%" HWADDR_PRIx, addr);
@@ -701,7 +701,7 @@ static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)MemoryRegion *mr =NULL ;void *ptr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return ;
@@ -777,7 +777,7 @@ static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)void *ptr;uint64_t physaddr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return ;
qapi/misc-target.json +18 -0
@@ -200,6 +200,24 @@ { 'command': 'query-sev-capabilities', 'returns': 'SevCapability', 'if': 'defined(TARGET_I386)' } +## +# @sev-inject-launch-secret: +# +# This command injects a secret blob into memory of SEV guest. +# +# @packet-header: the launch secret packet header encoded in base64 +# +# @secret: the launch secret data to be injected encoded in base64 +# +# @gpa: the guest physical address where secret will be injected. +# +# Since: 5.1 +# +## +{ 'command': 'sev-inject-launch-secret', + 'data': { 'packet-header': 'str', 'secret': 'str', 'gpa': 'uint64' }, + 'if': 'defined(TARGET_I386)' } + ## # @dump-skeys: #
target/i386/monitor.c +9 -0
@@ -736,3 +736,12 @@ SevCapability *qmp_query_sev_capabilities(Error **errp)return data; } + +void qmp_sev_inject_launch_secret (const char *packet_hdr, +const char *secret,uint64_t gpa, +Error **errp) +{ +if (sev_inject_launch_secret (packet_hdr, secret, gpa) !=0 ) { +error_setg (errp,"SEV inject secret failed" ); + } +}
target/i386/sev-stub.c +5 -0
@@ -48,3 +48,8 @@ SevCapability *sev_get_capabilities(void) {return NULL ; } +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa) +{ +return 1 ; +}
target/i386/sev.c +66 -0
78 lines not on this page · raw message
target/i386/sev_i386.h +3 -0
@@ -28,6 +28,9 @@#define SEV_POLICY_DOMAIN 0x10#define SEV_POLICY_SEV 0x20 +#define SEV_SECRET_HEADER_LEN 0x34 +#define SEV_SECRET_MAX_LEN 0x3E80 +extern bool sev_enabled (void );extern uint64_t sev_get_me_mask (void );extern SevInfo *sev_get_info (void );
target/i386/trace-events +1 -0
@@ -15,3 +15,4 @@ kvm_sev_launch_start(int policy, void *session, void *pdh) "policy 0x%x session kvm_sev_launch_update_data(void *addr, uint64_t len) "addr %p len 0x%" PRIu64 kvm_sev_launch_measurement(const char *value) "data %s" kvm_sev_launch_finish(void) "" +kvm_sev_launch_secret(uint64_t hpa, uint64_t hva, uint64_t secret, int len) "hpa 0x%" PRIx64 " hva 0x%" PRIx64 " data 0x%" PRIx64 " len %d"
Signature · 1 line
2.20.1 (Apple Git-117)
Quoted 198 lines · * Tobin Feldman-Fitzthum ([email protected]) wrote:
From: Tobin Feldman-Fitzthum <[email protected]>
AMD SEV allows a guest owner to inject a secret blob into the memory of a virtual machine. The secret is encrypted with the SEV Transport Encryption Key and integrity is guaranteed with the Transport Integrity Key. Although QEMU faciliates the injection of the launch secret, it cannot access the secret.
Signed-off-by Tobin Feldman-Fitzthum <[email protected]>--- include/monitor/monitor.h | 3 ++ include/sysemu/sev.h | 2 ++ monitor/misc.c | 8 ++--- qapi/misc-target.json | 18 +++++++++++ target/i386/monitor.c | 9 ++++++ target/i386/sev-stub.c | 5 +++ target/i386/sev.c | 66 +++++++++++++++++++++++++++++++++++++++ target/i386/sev_i386.h | 3 ++ target/i386/trace-events | 1 + 9 files changed, 111 insertions(+), 4 deletions(-)include/monitor/monitor.h +3
-0@@ -4,6 +4,7 @@#include "block/block.h" #include "qapi/qapi-types-misc.h" #include "qemu/readline.h" +#include "include/exec/hwaddr.h" extern __threadMonitor *cur_mon;typedef struct MonitorHMP MonitorHMP ;@@ -36,6 +37,8 @@ void monitor_flush(Monitor *mon);int monitor_set_cpu (int cpu_index);int monitor_get_cpu_index (void ); +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp); +void monitor_read_command (MonitorHMP *mon,int show_prompt);int monitor_read_password (MonitorHMP *mon,ReadLineFunc *readline_func,void *opaque);include/sysemu/sev.h +2
-0@@ -18,4 +18,6 @@void *sev_guest_init (const char *id);int sev_encrypt_data (void *handle,uint8_t *ptr,uint64_t len); +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa);#endif monitor/misc.c +4
-4@@ -674,10 +674,10 @@ static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)memory_dump (mon, count, format, size, addr,1 ); } -static void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,Error **errp) +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp) {MemoryRegionSection mrs =memory_region_find (get_system_memory (), - addr,1 ); + addr, size);if (!mrs.mr) {error_setg (errp,"No memory is mapped at address 0x%" HWADDR_PRIx, addr);@@ -701,7 +701,7 @@ static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)MemoryRegion *mr =NULL ;void *ptr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return ;@@ -777,7 +777,7 @@ static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)void *ptr;uint64_t physaddr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return ;qapi/misc-target.json +18
-0@@ -200,6 +200,24 @@ { 'command': 'query-sev-capabilities', 'returns': 'SevCapability', 'if': 'defined(TARGET_I386)' } +## +# @sev-inject-launch-secret: +# +# This command injects a secret blob into memory of SEV guest. +# +# @packet-header: the launch secret packet header encoded in base64 +# +# @secret: the launch secret data to be injected encoded in base64 +# +# @gpa: the guest physical address where secret will be injected. +# +# Since: 5.1 +# +## +{ 'command': 'sev-inject-launch-secret', + 'data': { 'packet-header': 'str', 'secret': 'str', 'gpa': 'uint64' }, + 'if': 'defined(TARGET_I386)' } + ## # @dump-skeys: #target/i386/monitor.c +9
-0@@ -736,3 +736,12 @@ SevCapability *qmp_query_sev_capabilities(Error **errp)return data; } + +void qmp_sev_inject_launch_secret (const char *packet_hdr, +const char *secret,uint64_t gpa, +Error **errp) +{ +if (sev_inject_launch_secret (packet_hdr, secret, gpa) !=0 ) { +error_setg (errp,"SEV inject secret failed" ); + } +}target/i386/sev-stub.c +5
-0@@ -48,3 +48,8 @@ SevCapability *sev_get_capabilities(void) {return NULL ; } +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa) +{ +return 1 ; +}target/i386/sev.c +35
-0@@ -28,6 +28,8 @@#include "sysemu/runstate.h" #include "trace.h" #include "migration/blocker.h" +#include "exec/address-spaces.h" +#include "monitor/monitor.h" #define TYPE_SEV_GUEST "sev-guest"#define SEV_GUEST (obj) \@@ -769,6 +771,70 @@ sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len)return 0 ; } +int sev_inject_launch_secret (const char *packet_hdr, +const char *secret,uint64_t gpa) +{ +struct kvm_sev_launch_secret input; +guchar *data =NULL , *hdr =NULL ; +int error, ret =1 ; +void *hva; +gsize hdr_sz =0 , data_sz =0 ; +Error *local_err =NULL ; +MemoryRegion *mr =NULL ; + +/* secret can be inject only in this state */ +if (!sev_check_state (sev_guest,SEV_STATE_LAUNCH_SECRET )) { +error_report ("SEV: Not in correct state. (LSECRET) %x" , + sev_guest->state); +return 1 ; + } + + hdr =g_base64_decode (packet_hdr, &hdr_sz); +if (!hdr || hdr_sz !=SEV_SECRET_HEADER_LEN ) { +error_report ("SEV: Failed to decode sequence header" ); +return 1 ; + } + + data =g_base64_decode (secret, &data_sz); +if (!data || data_sz <=0 || data_sz >SEV_SECRET_MAX_LEN ) { +error_report ("SEV: Failed to decode data" ); + goto err; + } + + hva =gpa2hva (&mr, gpa, data_sz, &local_err); +if (!hva) { +error_report ("SEV: Failed to calculate guest address." );
target/i386/sev.c sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len) · line 816
Quoted 10 lines
target/i386/sev.c +10
-0+ goto err; + } + + input.hdr_uaddr = (uint64_t )hdr; + input.hdr_len = hdr_sz; + + input.trans_uaddr = (uint64_t )data; + input.trans_len = data_sz; + + input.guest_uaddr = (uint64_t )hva;
Thanks for changing these; although it fails a 32bit build (which is probably mostly pointless for SEV, but it fails the build rather than building it out). The easy fix here seems to be:
(uint64_t)(uintptr_t)
Quoted 29 lines
target/i386/sev.c +21
-0+ input.guest_len = data_sz; + +trace_kvm_sev_launch_secret (gpa, input.guest_uaddr, + input.trans_uaddr, input.trans_len); + + ret =sev_ioctl (sev_guest->sev_fd,KVM_SEV_LAUNCH_SECRET , + &input, &error); +if (ret) { +error_report ("SEV: failed to inject secret ret=%d fw_error=%d '%s'" , + ret, error,fw_error_to_str (error)); + goto err; + } + + ret =0 ; + +err: +g_free (data); +g_free (hdr); +return ret; +} +static void sev_register_types (void ) {target/i386/sev_i386.h +0
-0
target/i386/sev_i386.h line 33
Quoted 6 lines
target/i386/sev_i386.h +3
-0@@ -28,6 +28,9 @@#define SEV_POLICY_DOMAIN 0x10#define SEV_POLICY_SEV 0x20 +#define SEV_SECRET_HEADER_LEN 0x34 +#define SEV_SECRET_MAX_LEN 0x3E80 +
Where does that maximum come from - I didn't find it in the spec.
Other than the 32bit ism above, and that minor question; I think this is fine.
Dave
Quoted 15 lines
target/i386/sev_i386.h +0
-0extern bool sev_enabled (void );extern uint64_t sev_get_me_mask (void );extern SevInfo *sev_get_info (void );target/i386/trace-events +1
-0@@ -15,3 +15,4 @@ kvm_sev_launch_start(int policy, void *session, void *pdh) "policy 0x%x session kvm_sev_launch_update_data(void *addr, uint64_t len) "addr %p len 0x%" PRIu64 kvm_sev_launch_measurement(const char *value) "data %s" kvm_sev_launch_finish(void) "" +kvm_sev_launch_secret(uint64_t hpa, uint64_t hva, uint64_t secret, int len) "hpa 0x%" PRIx64 " hva 0x%" PRIx64 " data 0x%" PRIx64 " len %d"Signature · 1 line
2.20.1 (Apple Git-117)
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Quoted 246 lines · Dr. David Alan Gilbert
Quoted 198 lines · * Tobin Feldman-Fitzthum ([email protected]) wrote:
From: Tobin Feldman-Fitzthum <[email protected]>
AMD SEV allows a guest owner to inject a secret blob into the memory of a virtual machine. The secret is encrypted with the SEV Transport Encryption Key and integrity is guaranteed with the Transport Integrity Key. Although QEMU faciliates the injection of the launch secret, it cannot access the secret.
Signed-off-by Tobin Feldman-Fitzthum <[email protected]>--- include/monitor/monitor.h | 3 ++ include/sysemu/sev.h | 2 ++ monitor/misc.c | 8 ++--- qapi/misc-target.json | 18 +++++++++++ target/i386/monitor.c | 9 ++++++ target/i386/sev-stub.c | 5 +++ target/i386/sev.c | 66 +++++++++++++++++++++++++++++++++++++++ target/i386/sev_i386.h | 3 ++ target/i386/trace-events | 1 + 9 files changed, 111 insertions(+), 4 deletions(-)include/monitor/monitor.h +3
-0@@ -4,6 +4,7 @@#include "block/block.h" #include "qapi/qapi-types-misc.h" #include "qemu/readline.h" +#include "include/exec/hwaddr.h" extern __threadMonitor *cur_mon;typedef struct MonitorHMP MonitorHMP ;@@ -36,6 +37,8 @@ void monitor_flush(Monitor *mon);int monitor_set_cpu (int cpu_index);int monitor_get_cpu_index (void ); +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp); +void monitor_read_command (MonitorHMP *mon,int show_prompt);int monitor_read_password (MonitorHMP *mon,ReadLineFunc *readline_func,void *opaque);include/sysemu/sev.h +2
-0@@ -18,4 +18,6 @@void *sev_guest_init (const char *id);int sev_encrypt_data (void *handle,uint8_t *ptr,uint64_t len); +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa);#endif monitor/misc.c +4
-4@@ -674,10 +674,10 @@ static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)memory_dump (mon, count, format, size, addr,1 ); } -static void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,Error **errp) +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp) {MemoryRegionSection mrs =memory_region_find (get_system_memory (), - addr,1 ); + addr, size);if (!mrs.mr) {error_setg (errp,"No memory is mapped at address 0x%" HWADDR_PRIx, addr);@@ -701,7 +701,7 @@ static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)MemoryRegion *mr =NULL ;void *ptr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return ;@@ -777,7 +777,7 @@ static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)void *ptr;uint64_t physaddr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return ;qapi/misc-target.json +18
-0@@ -200,6 +200,24 @@ { 'command': 'query-sev-capabilities', 'returns': 'SevCapability', 'if': 'defined(TARGET_I386)' } +## +# @sev-inject-launch-secret: +# +# This command injects a secret blob into memory of SEV guest. +# +# @packet-header: the launch secret packet header encoded in base64 +# +# @secret: the launch secret data to be injected encoded in base64 +# +# @gpa: the guest physical address where secret will be injected. +# +# Since: 5.1 +# +## +{ 'command': 'sev-inject-launch-secret', + 'data': { 'packet-header': 'str', 'secret': 'str', 'gpa': 'uint64' }, + 'if': 'defined(TARGET_I386)' } + ## # @dump-skeys: #target/i386/monitor.c +9
-0@@ -736,3 +736,12 @@ SevCapability *qmp_query_sev_capabilities(Error **errp)return data; } + +void qmp_sev_inject_launch_secret (const char *packet_hdr, +const char *secret,uint64_t gpa, +Error **errp) +{ +if (sev_inject_launch_secret (packet_hdr, secret, gpa) !=0 ) { +error_setg (errp,"SEV inject secret failed" ); + } +}target/i386/sev-stub.c +5
-0@@ -48,3 +48,8 @@ SevCapability *sev_get_capabilities(void) {return NULL ; } +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa) +{ +return 1 ; +}target/i386/sev.c +35
-0@@ -28,6 +28,8 @@#include "sysemu/runstate.h" #include "trace.h" #include "migration/blocker.h" +#include "exec/address-spaces.h" +#include "monitor/monitor.h" #define TYPE_SEV_GUEST "sev-guest"#define SEV_GUEST (obj) \@@ -769,6 +771,70 @@ sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len)return 0 ; } +int sev_inject_launch_secret (const char *packet_hdr, +const char *secret,uint64_t gpa) +{ +struct kvm_sev_launch_secret input; +guchar *data =NULL , *hdr =NULL ; +int error, ret =1 ; +void *hva; +gsize hdr_sz =0 , data_sz =0 ; +Error *local_err =NULL ; +MemoryRegion *mr =NULL ; + +/* secret can be inject only in this state */ +if (!sev_check_state (sev_guest,SEV_STATE_LAUNCH_SECRET )) { +error_report ("SEV: Not in correct state. (LSECRET) %x" , + sev_guest->state); +return 1 ; + } + + hdr =g_base64_decode (packet_hdr, &hdr_sz); +if (!hdr || hdr_sz !=SEV_SECRET_HEADER_LEN ) { +error_report ("SEV: Failed to decode sequence header" ); +return 1 ; + } + + data =g_base64_decode (secret, &data_sz); +if (!data || data_sz <=0 || data_sz >SEV_SECRET_MAX_LEN ) { +error_report ("SEV: Failed to decode data" ); + goto err; + } + + hva =gpa2hva (&mr, gpa, data_sz, &local_err); +if (!hva) { +error_report ("SEV: Failed to calculate guest address." );target/i386/sev.c sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len) · line 816
Quoted 10 lines
target/i386/sev.c +10
-0+ goto err; + } + + input.hdr_uaddr = (uint64_t )hdr; + input.hdr_len = hdr_sz; + + input.trans_uaddr = (uint64_t )data; + input.trans_len = data_sz; + + input.guest_uaddr = (uint64_t )hva;Thanks for changing these; although it fails a 32bit build (which is probably mostly pointless for SEV, but it fails the build rather than building it out). The easy fix here seems to be:
(uint64_t)(uintptr_t)Quoted 32 lines
target/i386/sev.c +21
-0+ input.guest_len = data_sz; + +trace_kvm_sev_launch_secret (gpa, input.guest_uaddr, + input.trans_uaddr, input.trans_len); + + ret =sev_ioctl (sev_guest->sev_fd,KVM_SEV_LAUNCH_SECRET , + &input, &error); +if (ret) { +error_report ("SEV: failed to inject secret ret=%d fw_error=%d '%s'" , + ret, error,fw_error_to_str (error)); + goto err; + } + + ret =0 ; + +err: +g_free (data); +g_free (hdr); +return ret; +} +static void sev_register_types (void ) {target/i386/sev_i386.h +0
-0@@ -28,6 +28,9 @@#define SEV_POLICY_DOMAIN 0x10#define SEV_POLICY_SEV 0x20
Quoted 4 lines
target/i386/sev_i386.h line 33
Quoted 3 lines
target/i386/sev_i386.h +3
-0+#define SEV_SECRET_HEADER_LEN 0x34 +#define SEV_SECRET_MAX_LEN 0x3E80 +Where does that maximum come from - I didn't find it in the spec.
The size of packet header is documented in Table 55 [1]. But, I am not sure how Tobin calculated the size of the secret max length. FW spec says that if it does not support the passed secret length then it will error out with INVALID_LENGTH.
I would avoid doing the header and secret length check in the Qemu. From HV point of view we consider them as a opaque blob and pass them as-is to the FW. We have seen that the size of the blob changed from one version to another.
[1]
https://www.amd.com/system/files/TechDocs/55766_SEV-KM_API_Specification.pdf
-Brijesh
Quoted 23 lines
Other than the 32bit ism above, and that minor question; I think this is fine.
Dave
Quoted 15 lines
target/i386/sev_i386.h +0
-0extern bool sev_enabled (void );extern uint64_t sev_get_me_mask (void );extern SevInfo *sev_get_info (void );target/i386/trace-events +1
-0@@ -15,3 +15,4 @@ kvm_sev_launch_start(int policy, void *session, void *pdh) "policy 0x%x session kvm_sev_launch_update_data(void *addr, uint64_t len) "addr %p len 0x%" PRIu64 kvm_sev_launch_measurement(const char *value) "data %s" kvm_sev_launch_finish(void) "" +kvm_sev_launch_secret(uint64_t hpa, uint64_t hva, uint64_t secret, int len) "hpa 0x%" PRIx64 " hva 0x%" PRIx64 " data 0x%" PRIx64 " len %d"Signature · 1 line
2.20.1 (Apple Git-117)--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Quoted 276 lines · Brijesh Singh
Quoted 259 lines · Dr. David Alan Gilbert
Quoted 210 lines · * Tobin Feldman-Fitzthum ([email protected]) wrote:
From: Tobin Feldman-Fitzthum <[email protected]>
AMD SEV allows a guest owner to inject a secret blob into the memory of a virtual machine. The secret is encrypted with the SEV Transport Encryption Key and integrity is guaranteed with the Transport Integrity Key. Although QEMU faciliates the injection of the launch secret, it cannot access the secret.
Signed-off-by Tobin Feldman-Fitzthum <[email protected]>--- include/monitor/monitor.h | 3 ++ include/sysemu/sev.h | 2 ++ monitor/misc.c | 8 ++--- qapi/misc-target.json | 18 +++++++++++ target/i386/monitor.c | 9 ++++++ target/i386/sev-stub.c | 5 +++ target/i386/sev.c | 66 +++++++++++++++++++++++++++++++++++++++ target/i386/sev_i386.h | 3 ++ target/i386/trace-events | 1 + 9 files changed, 111 insertions(+), 4 deletions(-)include/monitor/monitor.h +3
-0@@ -4,6 +4,7 @@#include "block/block.h" #include "qapi/qapi-types-misc.h" #include "qemu/readline.h" +#include "include/exec/hwaddr.h" extern __threadMonitor *cur_mon;typedef struct MonitorHMP MonitorHMP ;@@ -36,6 +37,8 @@ void monitor_flush(Monitor *mon);int monitor_set_cpu (int cpu_index);int monitor_get_cpu_index (void ); +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp); +void monitor_read_command (MonitorHMP *mon,int show_prompt); int monitor_read_password(MonitorHMP *mon, ReadLineFunc
*readline_func,void *opaque);include/sysemu/sev.h +2
-0@@ -18,4 +18,6 @@void *sev_guest_init (const char *id);int sev_encrypt_data (void *handle,uint8_t *ptr,uint64_t len); +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa);#endif monitor/misc.c +2
-2@@ -674,10 +674,10 @@ static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)memory_dump (mon, count, format, size, addr,1 ); } -static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp) +void *gpa2hva (MemoryRegion **p_mr,hwaddr addr,uint64_t size,Error **errp) {MemoryRegionSection mrs =memory_region_find (get_system_memory (), - addr,1 ); + addr, size);if (!mrs.mr) { error_setg(errp, "No memory is mapped at address 0x%"
HWADDR_PRIx, addr);monitor/misc.c +1
-1@@ -701,7 +701,7 @@ static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)MemoryRegion *mr =NULL ;void *ptr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return;monitor/misc.c +1
-1@@ -777,7 +777,7 @@ static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)void *ptr;uint64_t physaddr; - ptr =gpa2hva (&mr, addr, &local_err); + ptr =gpa2hva (&mr, addr,1 , &local_err);if (local_err) {error_report_err (local_err);return;qapi/misc-target.json +18
-0@@ -200,6 +200,24 @@ { 'command': 'query-sev-capabilities', 'returns': 'SevCapability', 'if': 'defined(TARGET_I386)' } +## +# @sev-inject-launch-secret: +# +# This command injects a secret blob into memory of SEV guest. +# +# @packet-header: the launch secret packet header encoded in base64 +# +# @secret: the launch secret data to be injected encoded in base64 +# +# @gpa: the guest physical address where secret will be injected. +# +# Since: 5.1 +# +## +{ 'command': 'sev-inject-launch-secret', + 'data': { 'packet-header': 'str', 'secret': 'str', 'gpa': 'uint64' }, + 'if': 'defined(TARGET_I386)' } + ## # @dump-skeys:#
target/i386/monitor.c +9
-0@@ -736,3 +736,12 @@ SevCapability *qmp_query_sev_capabilities(Error **errp)return data; } + +void qmp_sev_inject_launch_secret (const char *packet_hdr, +const char *secret,uint64_t gpa, +Error **errp) +{ +if (sev_inject_launch_secret (packet_hdr, secret, gpa) !=0 ) { +error_setg (errp,"SEV inject secret failed" ); + } +}target/i386/sev-stub.c +5
-0@@ -48,3 +48,8 @@ SevCapability *sev_get_capabilities(void) {return NULL ; } +int sev_inject_launch_secret (const char *hdr,const char *secret, +uint64_t gpa) +{ +return 1 ; +}target/i386/sev.c +35
-0@@ -28,6 +28,8 @@#include "sysemu/runstate.h" #include "trace.h" #include "migration/blocker.h" +#include "exec/address-spaces.h" +#include "monitor/monitor.h" #define TYPE_SEV_GUEST "sev-guest"#define SEV_GUEST (obj) \@@ -769,6 +771,70 @@ sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len)return 0 ; } +int sev_inject_launch_secret (const char *packet_hdr, +const char *secret,uint64_t gpa) +{ +struct kvm_sev_launch_secret input; +guchar *data =NULL , *hdr =NULL ; +int error, ret =1 ; +void *hva; +gsize hdr_sz =0 , data_sz =0 ; +Error *local_err =NULL ; +MemoryRegion *mr =NULL ; + +/* secret can be inject only in this state */ +if (!sev_check_state (sev_guest,SEV_STATE_LAUNCH_SECRET )) { +error_report ("SEV: Not in correct state. (LSECRET) %x" , + sev_guest->state); +return 1 ; + } + + hdr =g_base64_decode (packet_hdr, &hdr_sz); +if (!hdr || hdr_sz !=SEV_SECRET_HEADER_LEN ) { +error_report ("SEV: Failed to decode sequence header" ); +return 1 ; + } + + data =g_base64_decode (secret, &data_sz); +if (!data || data_sz <=0 || data_sz >SEV_SECRET_MAX_LEN ) { +error_report ("SEV: Failed to decode data" ); + goto err; + } + + hva =gpa2hva (&mr, gpa, data_sz, &local_err); +if (!hva) { +error_report ("SEV: Failed to calculate guest address." );target/i386/sev.c sev_encrypt_data(void *handle, uint8_t *ptr, · line 817
Quoted 10 lines
target/i386/sev.c +10
-0+ goto err; + } + + input.hdr_uaddr = (uint64_t )hdr; + input.hdr_len = hdr_sz; + + input.trans_uaddr = (uint64_t )data; + input.trans_len = data_sz; + + input.guest_uaddr = (uint64_t )hva;Thanks for changing these; although it fails a 32bit build (which is probably mostly pointless for SEV, but it fails the build rather than building it out). The easy fix here seems to be:
(uint64_t)(uintptr_t)Quoted 33 lines
target/i386/sev.c +21
-0+ input.guest_len = data_sz; + +trace_kvm_sev_launch_secret (gpa, input.guest_uaddr, + input.trans_uaddr, input.trans_len); + + ret =sev_ioctl (sev_guest->sev_fd,KVM_SEV_LAUNCH_SECRET , + &input, &error); +if (ret) { + error_report("SEV: failed to inject secret ret=%d fw_error=%d '%s'", + ret, error,fw_error_to_str (error)); + goto err; + } + + ret =0 ; + +err: +g_free (data); +g_free (hdr); +return ret; +} + static void
sev_register_types(void)
{target/i386/sev_i386.h +0
-0@@ -28,6 +28,9 @@#define SEV_POLICY_DOMAIN 0x10#define SEV_POLICY_SEV 0x20Quoted 4 lines
target/i386/sev_i386.h line 33
Quoted 3 lines
target/i386/sev_i386.h +3
-0+#define SEV_SECRET_HEADER_LEN 0x34 +#define SEV_SECRET_MAX_LEN 0x3E80 +Where does that maximum come from - I didn't find it in the spec.
The size of packet header is documented in Table 55 [1]. But, I am not sure how Tobin calculated the size of the secret max length. FW spec says that if it does not support the passed secret length then it will error out with
INVALID_LENGTH.I would avoid doing the header and secret length check in the Qemu. From HV point of view we consider them as a opaque blob and pass them as-is to the FW. We have seen that the size of the blob changed from one version to another.
Quoted 6 lines
[1]
https://www.amd.com/system/files/TechDocs/55766_SEV-KM_API_Specification.pdf-Brijesh
Thanks, Brijesh. I was hoping you could confirm some of those values.
I got the max secret length from table 54 which has a max value for the "GUEST_LENGTH". I am not entirely sure if I am interpreting the table correctly and I agree with you that checking the length is probably best left to the PSP.
-Tobin
Quoted 26 lines
Quoted 26 lines
Other than the 32bit ism above, and that minor question; I think this is fine.
Dave
Quoted 9 lines
target/i386/sev_i386.h +0
-0extern bool sev_enabled (void );extern uint64_t sev_get_me_mask (void );extern SevInfo *sev_get_info (void );target/i386/trace-events +0
-0@@ -15,3 +15,4 @@ kvm_sev_launch_start(int policy, void *session,void *pdh) "policy 0x%x session
Quoted 9 lines
kvm_sev_launch_update_data(void *addr, uint64_t len)"addr %p len
0x%" PRIu64
kvm_sev_launch_measurement(const char *value)"data %s"kvm_sev_launch_finish(void)""
+kvm_sev_launch_secret(uint64_t hpa,uint64_thva,uint64_tsecret, int len) "hpa 0x%" PRIx64 " hva 0x%" PRIx64 " data 0x%" PRIx64 " len %d" --
2.20.1 (Apple Git-117)--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Quoted 1 line · Dr. David Alan Gilbert
* Tobin Feldman-Fitzthum ([email protected]) wrote:
[...]
Quoted 9 lines
target/i386/sev.c sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len) · line 816
Quoted 4 lines
target/i386/sev.c +4
-0+ input.trans_uaddr = (uint64_t )data; + input.trans_len = data_sz; + + input.guest_uaddr = (uint64_t )hva;Thanks for changing these; although it fails a 32bit build (which is probably mostly pointless for SEV, but it fails the build rather than building it out). The easy fix here seems to be:
(uint64_t)(uintptr_t)
That's a pointer width issue. The recommended way to communicate to the compiler that we really want to cast a 32 bit pointer to a 64 bit value is actually to cast to unsigned long before casting to pointer, so
(uint64_t)(unsigned long)hva
Many other things work, of course, but if you follow the recommendation you (hopefully) don't trip future compiler warnings.
James
Quoted 18 lines · * James Bottomley ([email protected]) wrote:
Quoted 1 line · Dr. David Alan Gilbert
* Tobin Feldman-Fitzthum ([email protected]) wrote:
[...]
Quoted 9 lines
target/i386/sev.c sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len) · line 816
Quoted 4 lines
target/i386/sev.c +4
-0+ input.trans_uaddr = (uint64_t )data; + input.trans_len = data_sz; + + input.guest_uaddr = (uint64_t )hva;Thanks for changing these; although it fails a 32bit build (which is probably mostly pointless for SEV, but it fails the build rather than building it out). The easy fix here seems to be:
(uint64_t)(uintptr_t)That's a pointer width issue. The recommended way to communicate to the compiler that we really want to cast a 32 bit pointer to a 64 bit value is actually to cast to unsigned long before casting to pointer, so
Quoted 4 lines
(uint64_t)(unsigned long)hva
Many other things work, of course, but if you follow the recommendation you (hopefully) don't trip future compiler warnings.
OK, fair enough
(Out of curiosity can you explain why unsigned long not uintptr_t?)
Dave
Quoted 2 lines
James
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Quoted 20 lines · Dr. David Alan Gilbert
Quoted 19 lines · * James Bottomley ([email protected]) wrote:
Quoted 1 line · Dr. David Alan Gilbert
* Tobin Feldman-Fitzthum ([email protected]) wrote:
[...]
Quoted 9 lines
target/i386/sev.c sev_encrypt_data(void *handle, uint8_t *ptr, uint64_t len) · line 816
Quoted 4 lines
target/i386/sev.c +4
-0+ input.trans_uaddr = (uint64_t )data; + input.trans_len = data_sz; + + input.guest_uaddr = (uint64_t )hva;Thanks for changing these; although it fails a 32bit build (which is probably mostly pointless for SEV, but it fails the build rather than building it out). The easy fix here seems to be:
(uint64_t)(uintptr_t)That's a pointer width issue. The recommended way to communicate to the compiler that we really want to cast a 32 bit pointer to a 64 bit value is actually to cast to unsigned long before casting to pointer, so
Quoted 7 lines
Quoted 4 lines
(uint64_t)(unsigned long)hva
Many other things work, of course, but if you follow the recommendation you (hopefully) don't trip future compiler warnings.
OK, fair enough
(Out of curiosity can you explain why unsigned long notuintptr_t?)
You have to cast it to a matching variable size integer first, so both unsigned long and uintptr_t work because they're 64 bits on LP64 and 32 bits on ILP32. The only minor problem with uintptr_t is that the checker may or may not be programmed to know what it does and there's nothing more annoying than trying to get a warning message you know to be wrong fixed.
James