KVM: x86: Extend Spectre-v1 mitigation
Subsystems (5)
v2 cover KVM: x86: Extend Spectre-v1 mitigation
From: Nick Finco <[email protected]>
This extends the Spectre-v1 mitigation introduced in
commit 75f139aaf896 ("KVM: x86: Add memory barrier on vmcs field lookup") and commit 085331dfc6bb ("x86/kvm: Update spectre-v1 mitigation") in light of the Spectre-v1/L1TF combination described here:
https://xenbits.xen.org/xsa/advisory-289.html
As reported in the link, an attacker can use the cache-load part of a Spectre-v1 gadget to bring memory into the L1 cache, then use L1TF to leak the loaded memory. Note that this attack is not fully mitigated by core scheduling; firstly when "kvm-intel.vmentry_l1d_flush" is not set to "always", an attacker could use L1TF on the same thread that loaded the memory values in the cache on paths that do not flush the L1 cache on VMEntry. Otherwise, an attacker could perform this attack using a collusion of two sibling hyperthreads: one that loads memory values in the cache during VMExit handling and another that performs L1TF to leak them.
This patch uses array_index_nospec() to prevent index computations from causing speculative loads into the L1 cache. These cases involve a bounds check followed by a memory read using the index; this is more common than the full Spectre-v1 pattern. In some cases, the index computation can be eliminated entirely by small amounts of refactoring.
Marios Pomonis (13):
KVM: x86: Protect x86_decode_insn from Spectre-v1/L1TF attacks
KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from
Spectre-v1/L1TF attacks
KVM: x86: Refactor picdev_write() to prevent Spectre-v1/L1TF attacks
KVM: x86: Protect ioapic_read_indirect() from Spectre-v1/L1TF attacks
KVM: x86: Protect ioapic_write_indirect() from Spectre-v1/L1TF attacks
KVM: x86: Protect kvm_lapic_reg_write() from Spectre-v1/L1TF attacks
KVM: x86: Protect MSR-based index computations in
fixed_msr_to_seg_unit()
KVM: x86: Protect MSR-based index computations in pmu.h
KVM: x86: Protect MSR-based index computations from Spectre-v1/L1TF
attacks in x86.c
KVM: x86: Protect memory accesses from Spectre-v1/L1TF attacks in
x86.c KVM: x86: Protect exit_reason from being used in Spectre-v1/L1TF
attacks
KVM: x86: Protect DR-based index computations from Spectre-v1/L1TF
attacks
KVM: x86: Protect pmu_intel.c from Spectre-v1/L1TF attacks
arch/x86/kvm/emulate.c | 11 ++++-- arch/x86/kvm/hyperv.c | 10 +++-- arch/x86/kvm/i8259.c | 6 ++- arch/x86/kvm/ioapic.c | 15 +++++--- arch/x86/kvm/lapic.c | 13 +++++-- arch/x86/kvm/mtrr.c | 8 +++- arch/x86/kvm/pmu.h | 18 +++++++-- arch/x86/kvm/vmx/pmu_intel.c | 24 ++++++++---- arch/x86/kvm/vmx/vmx.c | 71 +++++++++++++++++++++--------------- arch/x86/kvm/x86.c | 18 +++++++-- 10 files changed, 129 insertions(+), 65 deletions(-)
Signature · 1 line
2.24.0.393.g34dc348eaf-goog
PATCH v2 1/13 KVM: x86: Protect x86_decode_insn from Spectre-v1/L1TF attacks
This fixes a Spectre-v1/L1TF vulnerability in x86_decode_insn(). kvm_emulate_instruction() (an ancestor of x86_decode_insn()) is an exported symbol, so KVM should treat it conservatively from a security perspective.
--- arch/x86/kvm/emulate.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
arch/x86/kvm/emulate.c +8 -3
@@ -5303,10 +5303,15 @@ int x86_decode_insn(struct x86_emulate_ctxt *ctxt, void *insn, int insn_len) }break ;case Escape: -if (ctxt->modrm >0xbf ) - opcode = opcode.u.esc->high[ctxt->modrm -0xc0 ]; -else +if (ctxt->modrm >0xbf ) { +size_t size =ARRAY_SIZE (opcode.u.esc->high); +u32 index =array_index_nospec ( + ctxt->modrm -0xc0 , size); + + opcode = opcode.u.esc->high[index]; + }else { opcode = opcode.u.esc->op[(ctxt->modrm >>3 ) &7 ]; + }break ;case InstrDual:if ((ctxt->modrm >>6 ) ==3 )
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 01/13] KVM: x86: Protect x86_decode_insn from Spectre-v1/L1TF attacks
Quoted 11 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
x86_decode_insn().kvm_emulate_instruction()(an ancestor ofx86_decode_insn()) is an exported symbol, so KVM should treat it conservatively from a security perspective.Fixes commit 045a282ca415 ("KVM: emulator: implement fninit, fnstsw, fnstcw")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 2/13 KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes Spectre-v1/L1TF vulnerabilities in kvm_hv_msr_get_crash_data() and kvm_hv_msr_set_crash_data().
These functions contain index computations that use the (attacker-controlled) MSR number.
--- arch/x86/kvm/hyperv.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
arch/x86/kvm/hyperv.c +6 -4
@@ -809,11 +809,12 @@ static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 *pdata) { struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param); -if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ; - *pdata = hv->hv_crash_param[index]; + *pdata = hv->hv_crash_param[array_index_nospec (index, size)];return 0 ; }
@@ -852,11 +853,12 @@ static int kvm_hv_msr_set_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 data) {struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param); -if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ; - hv->hv_crash_param[index] = data; + hv->hv_crash_param[array_index_nospec (index, size)] = data;return 0 ; }
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Vitaly Kuznetsov
maintainerRe: [PATCH v2 02/13] KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from Spectre-v1/L1TF attacks
Quoted 4 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
kvm_hv_msr_get_crash_data()andkvm_hv_msr_set_crash_data().
These functions contain index computations that use the (attacker-controlled) MSR number.
Just to educate myself,
in both cases 'index' is equal to 'msr - HV_X64_MSR_CRASH_P0' where 'msr' is constrained:
case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4:
....
and moreover, kvm_hv_{get,set}_msr_common() is only being called for a narrow set of MSRs. How can an atacker overcome these limitations?
Quoted 44 lines
Fixes commit e7d9513b60e8 ("kvm/x86: added hyper-v crash msrs into kvm hyperv context")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>--- arch/x86/kvm/hyperv.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)arch/x86/kvm/hyperv.c +6
-4@@ -809,11 +809,12 @@ static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 *pdata) { struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param); -if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ; - *pdata = hv->hv_crash_param[index]; + *pdata = hv->hv_crash_param[array_index_nospec (index, size)];return 0 ; }@@ -852,11 +853,12 @@ static int kvm_hv_msr_set_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 data) {struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param); -if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ; - hv->hv_crash_param[index] = data; + hv->hv_crash_param[array_index_nospec (index, size)] = data;return 0 ; }
Signature · 1 line
Vitaly
Re: [PATCH v2 02/13] KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from Spectre-v1/L1TF attacks
Quoted 10 lines · Vitaly Kuznetsov
Quoted 4 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
kvm_hv_msr_get_crash_data()andkvm_hv_msr_set_crash_data().
These functions contain index computations that use the (attacker-controlled) MSR number.Just to educate myself,
Quoted 8 lines
in both cases 'index' is equal to 'msr -
HV_X64_MSR_CRASH_P0' where 'msr' is constrained:
caseHV_X64_MSR_CRASH_P0...HV_X64_MSR_CRASH_P4:....and moreover, kvm_hv_{get,set}_msr_common() is only being called for a narrow set of MSRs. How can an atacker overcome these limitations?
This attack scenario relies on speculative execution. Practically, one could train the branch predictors involved to speculatively execute this path even if the adversary-supplied MSR number does not fall into the legitimate range. The adversary-supplied MSR number however is going to be used when -speculatively- computing the index of the array thus allowing an attacker to load normally illegitimate memory values in the L1 cache.
Quoted 48 lines
Quoted 34 lines
Fixes commit e7d9513b60e8 ("kvm/x86: added hyper-v crash msrs into kvm hyperv context")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>--- arch/x86/kvm/hyperv.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)arch/x86/kvm/hyperv.c +3
-2@@ -809,11 +809,12 @@ static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 *pdata) { struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param); -if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ; - *pdata = hv->hv_crash_param[index]; + *pdata = hv->hv_crash_param[array_index_nospec (index, size)];return 0 ; }@@ -852,11 +853,12 @@ static int kvm_hv_msr_set_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 data) {struct kvm_hv *hv = &vcpu->kvm->arch.hyperv;arch/x86/kvm/hyperv.c static int kvm_hv_msr_set_crash_data(struct kvm_vcpu *vcpu, · line 863
Quoted 10 lines
arch/x86/kvm/hyperv.c +3
-2+size_t size =ARRAY_SIZE (hv->hv_crash_param); -if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ; - hv->hv_crash_param[index] = data; + hv->hv_crash_param[array_index_nospec (index, size)] = data;return 0 ; }--
Vitaly
Signature · 4 lines
Marios Pomonis Software Engineer, Security GCP Platform Security US-KIR-6THC
Re: [PATCH v2 02/13] KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from Spectre-v1/L1TF attacks
In reply to Marios PomonisQuoted 20 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
kvm_hv_msr_get_crash_data()andkvm_hv_msr_set_crash_data().
These functions contain index computations that use the (attacker-controlled) MSR number.Fixes commit e7d9513b60e8 ("kvm/x86: added hyper-v crash msrs into kvm hyperv context")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>--- arch/x86/kvm/hyperv.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)arch/x86/kvm/hyperv.c +0
-0
arch/x86/kvm/hyperv.c static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, · line 815
Quoted 8 lines
arch/x86/kvm/hyperv.c +2
-1@@ -809,11 +809,12 @@ static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 *pdata) { struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param); -if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ;
The fact that we do a WARN_ON_ONCE here, should actually tell that index is not user controllable. Otherwise this would indicate the possibility to trigger a kernel warning from a malicious user space. So
a: we do not need this change
or
b: we must also fix the WARN_ON_ONCE
Re: [PATCH v2 02/13] KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from Spectre-v1/L1TF attacks
Quoted 29 lines · Christian Borntraeger
Quoted 25 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
kvm_hv_msr_get_crash_data()andkvm_hv_msr_set_crash_data().
These functions contain index computations that use the (attacker-controlled) MSR number.Fixes commit e7d9513b60e8 ("kvm/x86: added hyper-v crash msrs into kvm hyperv context")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>--- arch/x86/kvm/hyperv.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)arch/x86/kvm/hyperv.c +1
-0@@ -809,11 +809,12 @@ static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 *pdata) { struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param);
Quoted 10 lines
arch/x86/kvm/hyperv.c static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, · line 815
Quoted 3 lines
arch/x86/kvm/hyperv.c +1
-1-if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ;The fact that we do a
WARN_ON_ONCEhere, should actually tell that index is not user controllable. Otherwise this would indicate the possibility to trigger a kernel warning from a malicious user space. So
a: we do not need this change
or
b: we must also fix theWARN_ON_ONCE
That isn't quite true. The issue is *speculative* execution down this path.
The call site does constrain the *actual* value of index:
case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4:
return kvm_hv_msr_get_crash_data(...);
However, it is possible to train the branch predictor to go down this path using valid indices and subsequently pass what would be an invalid index. The CPU will speculatively follow this path and may pull interesting data into the cache before it realizes its mistake and corrects.
Re: [PATCH v2 02/13] KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from Spectre-v1/L1TF attacks
Quoted 46 lines · Jim Mattson
Quoted 29 lines · Christian Borntraeger
Quoted 25 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
kvm_hv_msr_get_crash_data()andkvm_hv_msr_set_crash_data().
These functions contain index computations that use the (attacker-controlled) MSR number.Fixes commit e7d9513b60e8 ("kvm/x86: added hyper-v crash msrs into kvm hyperv context")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>--- arch/x86/kvm/hyperv.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)arch/x86/kvm/hyperv.c +1
-0@@ -809,11 +809,12 @@ static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, u32 index, u64 *pdata) { struct kvm_hv *hv = &vcpu->kvm->arch.hyperv; +size_t size =ARRAY_SIZE (hv->hv_crash_param);Quoted 10 lines
arch/x86/kvm/hyperv.c static int kvm_hv_msr_get_crash_data(struct kvm_vcpu *vcpu, · line 815
Quoted 3 lines
arch/x86/kvm/hyperv.c +1
-1-if (WARN_ON_ONCE (index >=ARRAY_SIZE (hv->hv_crash_param))) +if (WARN_ON_ONCE (index >= size))return -EINVAL ;The fact that we do a
WARN_ON_ONCEhere, should actually tell that index is not user controllable. Otherwise this would indicate the possibility to trigger a kernel warning from a malicious user space. So
a: we do not need this change
or
b: we must also fix theWARN_ON_ONCEThat isn't quite true. The issue is *speculative* execution down this path.
The call site does constrain the *actual* value of index:
Quoted 8 lines
case
HV_X64_MSR_CRASH_P0...HV_X64_MSR_CRASH_P4:return kvm_hv_msr_get_crash_data(...);However, it is possible to train the branch predictor to go down this path using valid indices and subsequently pass what would be an invalid index. The CPU will speculatively follow this path and may pull interesting data into the cache before it realizes its mistake and corrects.
Yes, you are right.
Jim Mattson
Reviewed-byRe: [PATCH v2 02/13] KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from Spectre-v1/L1TF attacks
Quoted 15 lines · Christian Borntraeger
Quoted 11 lines · Jim Mattson
Quoted 9 lines · Christian Borntraeger
Quoted 5 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
kvm_hv_msr_get_crash_data()andkvm_hv_msr_set_crash_data().
These functions contain index computations that use the (attacker-controlled) MSR number.
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Fixes commit e7d9513b60e8 ("kvm/x86: added hyper-v crash msrs into kvm hyperv context")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 3/13 KVM: x86: Refactor picdev_write() to prevent Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in picdev_write(). It replaces index computations based on the (attacked-controlled) port number with constants through a minor refactoring.
--- arch/x86/kvm/i8259.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
arch/x86/kvm/i8259.c +5 -1
@@ -460,10 +460,14 @@ static int picdev_write(struct kvm_pic *s,switch (addr) {case 0x20 :case 0x21 : +pic_lock (s); +pic_ioport_write (&s->pics[0 ], addr, data); +pic_unlock (s); +break ;case 0xa0 :case 0xa1 :pic_lock (s); -pic_ioport_write (&s->pics[addr >>7 ], addr, data); +pic_ioport_write (&s->pics[1 ], addr, data);pic_unlock (s);break ;case 0x4d0 :
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 03/13] KVM: x86: Refactor picdev_write() to prevent Spectre-v1/L1TF attacks
Quoted 11 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
picdev_write(). It replaces index computations based on the (attacked-controlled) port number with constants through a minor refactoring.Fixes commit 85f455f7ddbe ("KVM: Add support for in-kernel PIC emulation")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 4/13 KVM: x86: Protect ioapic_read_indirect() from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in ioapic_read_indirect(). This function contains index computations based on the (attacker-controlled) IOREGSEL register.
--- arch/x86/kvm/ioapic.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-)
arch/x86/kvm/ioapic.c +8 -6
@@ -36,6 +36,7 @@#include <linux/io.h> #include <linux/slab.h> #include <linux/export.h> +#include <linux/nospec.h> #include <asm/processor.h> #include <asm/page.h> #include <asm/current.h>
@@ -68,13 +69,14 @@ static unsigned long ioapic_read_indirect(struct kvm_ioapic *ioapic,default : {u32 redir_index = (ioapic->ioregsel -0x10 ) >>1 ; -u64 redir_content; +u64 redir_content = ~0ULL ; -if (redir_index <IOAPIC_NUM_PINS ) - redir_content = - ioapic->redirtbl[redir_index].bits; -else - redir_content = ~0ULL ; +if (redir_index <IOAPIC_NUM_PINS ) { +u32 index =array_index_nospec ( + redir_index,IOAPIC_NUM_PINS ); + + redir_content = ioapic->redirtbl[index].bits; + } result = (ioapic->ioregsel &0x1 ) ? (redir_content >> 32) & 0xffffffff :
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 04/13] KVM: x86: Protect ioapic_read_indirect() from Spectre-v1/L1TF attacks
Quoted 11 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
ioapic_read_indirect(). This function contains index computations based on the (attacker-controlled) IOREGSEL register.Fixes commit a2c118bfab8b ("KVM: Fix bounds checking in ioapic indirect register reads (CVE-2013-1798)")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 5/13 KVM: x86: Protect ioapic_write_indirect() from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in ioapic_write_indirect(). This function contains index computations based on the (attacker-controlled) IOREGSEL register.
This patch depends on patch
"KVM: x86: Protect ioapic_read_indirect() from Spectre-v1/L1TF attacks".
--- arch/x86/kvm/ioapic.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/kvm/ioapic.c +1 -0
@@ -294,6 +294,7 @@ static void ioapic_write_indirect(struct kvm_ioapic *ioapic, u32 val)if (index >=IOAPIC_NUM_PINS )return ; + index =array_index_nospec (index,IOAPIC_NUM_PINS ); e = &ioapic->redirtbl[index]; mask_before = e->fields.mask;/* Preserve read-only fields */
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 05/13] KVM: x86: Protect ioapic_write_indirect() from Spectre-v1/L1TF attacks
Quoted 8 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
ioapic_write_indirect(). This function contains index computations based on the (attacker-controlled) IOREGSEL register.This patch depends on patch
"KVM: x86: Protectioapic_read_indirect()from Spectre-v1/L1TF attacks".
Quoted 6 lines
Fixes commit 70f93dae32ac ("KVM: Use temporary variable to shorten lines.")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 6/13 KVM: x86: Protect kvm_lapic_reg_write() from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in kvm_lapic_reg_write(). This function contains index computations based on the (attacker-controlled) MSR number.
--- arch/x86/kvm/lapic.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-)
arch/x86/kvm/lapic.c +9 -4
@@ -1963,15 +1963,20 @@ int kvm_lapic_reg_write(struct kvm_lapic *apic, u32 reg, u32 val)case APIC_LVTTHMR :case APIC_LVTPC :case APIC_LVT1 : -case APIC_LVTERR : +case APIC_LVTERR : {/* TODO: Check vector */ +size_t size; +u32 index; +if (!kvm_apic_sw_enabled (apic)) val |=APIC_LVT_MASKED ; - - val &= apic_lvt_mask[(reg -APIC_LVTT ) >>4 ]; + size =ARRAY_SIZE (apic_lvt_mask); + index =array_index_nospec ( + (reg -APIC_LVTT ) >>4 , size); + val &= apic_lvt_mask[index];kvm_lapic_set_reg (apic, reg, val); -break ; + }case APIC_LVTT :if (!kvm_apic_sw_enabled (apic))
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 06/13] KVM: x86: Protect kvm_lapic_reg_write() from Spectre-v1/L1TF attacks
Quoted 11 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
kvm_lapic_reg_write(). This function contains index computations based on the (attacker-controlled) MSR number.Fixes commit 0105d1a52640 ("KVM: x2apic interface to lapic")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 7/13 KVM: x86: Protect MSR-based index computations in fixed_msr_to_seg_unit() from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in fixed_msr_to_seg_unit(). This function contains index computations based on the (attacker-controlled) MSR number.
--- arch/x86/kvm/mtrr.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
arch/x86/kvm/mtrr.c +6 -2
@@ -192,11 +192,15 @@ static bool fixed_msr_to_seg_unit(u32 msr, int *seg, int *unit)break ; case MSR_MTRRfix16K_80000 ... MSR_MTRRfix16K_A0000: *seg =1 ; - *unit = msr - MSR_MTRRfix16K_80000; + *unit =array_index_nospec ( + msr - MSR_MTRRfix16K_80000, + MSR_MTRRfix16K_A0000 - MSR_MTRRfix16K_80000 +1 );break ; case MSR_MTRRfix4K_C0000 ... MSR_MTRRfix4K_F8000: *seg =2 ; - *unit = msr - MSR_MTRRfix4K_C0000; + *unit =array_index_nospec ( + msr - MSR_MTRRfix4K_C0000, + MSR_MTRRfix4K_F8000 - MSR_MTRRfix4K_C0000 +1 );break ;default :return false;
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH v2 07/13] KVM: x86: Protect MSR-based index computations in fixed_msr_to_seg_unit() from Spectre-v1/L1TF attacks
Hi Sasha,
These build issues can be fixed by including linux/nospec.h to arch/x86/kvm/mtrr.c. Below you can find a patch that compiles on both v4.9.206 and v4.4.206.
Please let me know if you need anything else.
Marios
========
arch/x86/kvm/mtrr.c +1 -0
@@ -18,6 +18,7 @@#include <linux/kvm_host.h> #include <asm/mtrr.h> +#include <linux/nospec.h> #include "cpuid.h" #include "mmu.h"
@@ -202,11 +203,15 @@ static bool fixed_msr_to_seg_unit(u32 msr, int
*seg, int *unit)
break;
case MSR_MTRRfix16K_80000 ... MSR_MTRRfix16K_A0000:
*seg = 1;
- *unit = msr - MSR_MTRRfix16K_80000;
+ *unit = array_index_nospec(
+ msr - MSR_MTRRfix16K_80000,
+ MSR_MTRRfix16K_A0000 - MSR_MTRRfix16K_80000 + 1);
break;
case MSR_MTRRfix4K_C0000 ... MSR_MTRRfix4K_F8000:
*seg = 2;
- *unit = msr - MSR_MTRRfix4K_C0000;
+ *unit = array_index_nospec(
+ msr - MSR_MTRRfix4K_C0000,
+ MSR_MTRRfix4K_F8000 - MSR_MTRRfix4K_C0000 + 1);
break;
default:
return false;Quoted 28 lines · Sasha Levin
Hi,
[This is an automated email]
This commit has been processed because it contains a "Fixes:" tag, fixing commit:
de9aef5e1ad6("KVM: MTRR: introducefixed_mtrr_segmenttable").The bot has tested the following trees: v5.4.5, v5.3.18, v4.19.90, v4.14.159, v4.9.206, v4.4.206.
v5.4.5: Build OK!
v5.3.18: Build OK!
v4.19.90: Build OK!
v4.14.159: Build OK!
v4.9.206: Build failed! Errors:
arch/x86/kvm/mtrr.c:205:11: error: implicit declaration of function ‘array_index_nospec’; did you mean ‘array_index_mask_nospec’? [-Werror=implicit-function-declaration]v4.4.206: Build failed! Errors:
arch/x86/kvm/mtrr.c:205:11: error: implicit declaration of function ‘array_index_nospec’; did you mean ‘array_index_mask_nospec’? [-Werror=implicit-function-declaration]NOTE: The patch will not be queued to stable trees until it is upstream.
How should we proceed with this patch?
--
Thanks,
Sasha
Signature · 4 lines
Marios Pomonis Software Engineer, Security GCP Platform Security US-KIR-6THC
Re: [PATCH v2 07/13] KVM: x86: Protect MSR-based index computations in fixed_msr_to_seg_unit() from Spectre-v1/L1TF attacks
In reply to Marios PomonisQuoted 11 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
fixed_msr_to_seg_unit(). This function contains index computations based on the (attacker-controlled) MSR number.Fixes commit de9aef5e1ad6 ("KVM: MTRR: introduce fixed_mtrr_segment table")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 8/13 KVM: x86: Protect MSR-based index computations in pmu.h from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in the get_gp_pmc() and get_fixed_pmc() functions.
They both contain index computations based on the (attacker-controlled) MSR number.
--- arch/x86/kvm/pmu.h | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)
arch/x86/kvm/pmu.h +14 -4
@@ -2,6 +2,8 @@#ifndef __KVM_X86_PMU_H#define __KVM_X86_PMU_H +#include <linux/nospec.h> +#define vcpu_to_pmu (vcpu) (&(vcpu)->arch.pmu)#define pmu_to_vcpu (pmu) (container_of((pmu), struct kvm_vcpu, arch.pmu))#define pmc_to_pmu (pmc) (&(pmc)->vcpu->arch.pmu)
@@ -102,8 +104,12 @@ static inline bool kvm_valid_perf_global_ctrl(struct kvm_pmu *pmu,static inline struct kvm_pmc *get_gp_pmc (struct kvm_pmu *pmu,u32 msr,u32 base) { -if (msr >= base && msr < base + pmu->nr_arch_gp_counters) -return &pmu->gp_counters[msr - base]; +if (msr >= base && msr < base + pmu->nr_arch_gp_counters) { +u32 index =array_index_nospec (msr - base, + pmu->nr_arch_gp_counters); + +return &pmu->gp_counters[index]; + }return NULL ; }
@@ -113,8 +119,12 @@ static inline struct kvm_pmc *get_fixed_pmc(struct kvm_pmu *pmu, u32 msr) {int base =MSR_CORE_PERF_FIXED_CTR0 ; -if (msr >= base && msr < base + pmu->nr_arch_fixed_counters) -return &pmu->fixed_counters[msr - base]; +if (msr >= base && msr < base + pmu->nr_arch_fixed_counters) { +u32 index =array_index_nospec (msr - base, + pmu->nr_arch_fixed_counters); + +return &pmu->fixed_counters[index]; + }return NULL ; }
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 08/13] KVM: x86: Protect MSR-based index computations in pmu.h from Spectre-v1/L1TF attacks
Quoted 6 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in the
get_gp_pmc()andget_fixed_pmc()functions.
They both contain index computations based on the (attacker-controlled) MSR number.
Quoted 6 lines
Fixes commit 25462f7f5295 ("KVM: x86/vPMU: Define kvm_pmu_ops to support vPMU function dispatch")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 9/13 KVM: x86: Protect MSR-based index computations from Spectre-v1/L1TF attacks in x86.c
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in set_msr_mce() and get_msr_mce().
Both functions contain index computations based on the (attacker-controlled) MSR number.
--- arch/x86/kvm/x86.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +8 -2
@@ -2496,7 +2496,10 @@ static int set_msr_mce(struct kvm_vcpu *vcpu, struct msr_data *msr_info)default :if (msr >=MSR_IA32_MC0_CTL && msr <MSR_IA32_MCx_CTL (bank_num)) { -u32 offset = msr -MSR_IA32_MC0_CTL ; +u32 offset =array_index_nospec ( + msr -MSR_IA32_MC0_CTL , +MSR_IA32_MCx_CTL (bank_num) -MSR_IA32_MC0_CTL ); +/* only 0 or all 1s can be written to IA32_MCi_CTL * some Linux kernels though clear bit 10 in bank 4 to * workaround a BIOS/GART TBL issue on AMD K8s, ignore
@@ -2937,7 +2940,10 @@ static int get_msr_mce(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata, bool host)default :if (msr >=MSR_IA32_MC0_CTL && msr <MSR_IA32_MCx_CTL (bank_num)) { -u32 offset = msr -MSR_IA32_MC0_CTL ; +u32 offset =array_index_nospec ( + msr -MSR_IA32_MC0_CTL , +MSR_IA32_MCx_CTL (bank_num) -MSR_IA32_MC0_CTL ); + data = vcpu->arch.mce_banks[offset];break ; }
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 09/13] KVM: x86: Protect MSR-based index computations from Spectre-v1/L1TF attacks in x86.c
Quoted 6 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
set_msr_mce()andget_msr_mce().
Both functions contain index computations based on the (attacker-controlled) MSR number.
Quoted 6 lines
Fixes commit 890ca9aefa78 ("KVM: Add MCE support")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 10/13 KVM: x86: Protect memory accesses from Spectre-v1/L1TF attacks in x86.c
In reply to Marios PomonisThis fixes Spectre-v1/L1TF vulnerabilities in vmx_read_guest_seg_selector(), vmx_read_guest_seg_base(), vmx_read_guest_seg_limit() and vmx_read_guest_seg_ar(). These functions contain index computations based on the (attacker-influenced) segment value.
--- arch/x86/kvm/vmx/vmx.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
arch/x86/kvm/vmx/vmx.c +12 -4
@@ -753,7 +753,9 @@ static bool vmx_segment_cache_test_set(struct vcpu_vmx *vmx, unsigned seg,static u16 vmx_read_guest_seg_selector (struct vcpu_vmx *vmx,unsigned seg) { -u16 *p = &vmx->segment_cache.seg[seg].selector; +size_t size =ARRAY_SIZE (vmx->segment_cache.seg); +size_t index =array_index_nospec (seg, size); +u16 *p = &vmx->segment_cache.seg[index].selector;if (!vmx_segment_cache_test_set (vmx, seg,SEG_FIELD_SEL )) *p =vmcs_read16 (kvm_vmx_segment_fields[seg].selector);
@@ -762,7 +764,9 @@ static u16 vmx_read_guest_seg_selector(struct vcpu_vmx *vmx, unsigned seg)static ulong vmx_read_guest_seg_base (struct vcpu_vmx *vmx,unsigned seg) { -ulong *p = &vmx->segment_cache.seg[seg].base; +size_t size =ARRAY_SIZE (vmx->segment_cache.seg); +size_t index =array_index_nospec (seg, size); +ulong *p = &vmx->segment_cache.seg[index].base;if (!vmx_segment_cache_test_set (vmx, seg,SEG_FIELD_BASE )) *p =vmcs_readl (kvm_vmx_segment_fields[seg].base);
@@ -771,7 +775,9 @@ static ulong vmx_read_guest_seg_base(struct vcpu_vmx *vmx, unsigned seg)static u32 vmx_read_guest_seg_limit (struct vcpu_vmx *vmx,unsigned seg) { -u32 *p = &vmx->segment_cache.seg[seg].limit; +size_t size =ARRAY_SIZE (vmx->segment_cache.seg); +size_t index =array_index_nospec (seg, size); +u32 *p = &vmx->segment_cache.seg[index].limit;if (!vmx_segment_cache_test_set (vmx, seg,SEG_FIELD_LIMIT )) *p =vmcs_read32 (kvm_vmx_segment_fields[seg].limit);
@@ -780,7 +786,9 @@ static u32 vmx_read_guest_seg_limit(struct vcpu_vmx *vmx, unsigned seg)static u32 vmx_read_guest_seg_ar (struct vcpu_vmx *vmx,unsigned seg) { -u32 *p = &vmx->segment_cache.seg[seg].ar; +size_t size =ARRAY_SIZE (vmx->segment_cache.seg); +size_t index =array_index_nospec (seg, size); +u32 *p = &vmx->segment_cache.seg[index].ar;if (!vmx_segment_cache_test_set (vmx, seg,SEG_FIELD_AR )) *p =vmcs_read32 (kvm_vmx_segment_fields[seg].ar_bytes);
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 10/13] KVM: x86: Protect memory accesses from Spectre-v1/L1TF attacks in x86.c
Quoted 7 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
vmx_read_guest_seg_selector(),vmx_read_guest_seg_base(),vmx_read_guest_seg_limit()andvmx_read_guest_seg_ar(). These functions contain index computations based on the (attacker-influenced) segment value.
Quoted 6 lines
Fixes commit 2fb92db1ec08 ("KVM: VMX: Cache vmcs segment fields")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
Paolo Bonzini
maintainerRe: [PATCH v2 10/13] KVM: x86: Protect memory accesses from Spectre-v1/L1TF attacks in x86.c
In reply to Marios PomonisQuoted 7 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
vmx_read_guest_seg_selector(),vmx_read_guest_seg_base(),vmx_read_guest_seg_limit()andvmx_read_guest_seg_ar(). These functions contain index computations based on the (attacker-influenced) segment value.Fixes commit 2fb92db1ec08 ("KVM: VMX: Cache vmcs segment fields")
I think we could instead do
arch/x86/kvm/emulate.c +0 -0
@@ -5195,16 +5195,28 @@ int x86_decode_insn(struct x86_emulate_ctxt
*ctxt, void *insn, int insn_len)
ctxt->ad_bytes = def_ad_bytes ^ 6;
break;
case 0x26: /* ES override */
+ has_seg_override = true;
+ ctxt->seg_override = VCPU_SREG_ES;
+ break;
case 0x2e: /* CS override */
+ has_seg_override = true;
+ ctxt->seg_override = VCPU_SREG_CS;
+ break;
case 0x36: /* SS override */
+ has_seg_override = true;
+ ctxt->seg_override = VCPU_SREG_SS;
+ break;
case 0x3e: /* DS override */
has_seg_override = true;
- ctxt->seg_override = (ctxt->b >> 3) & 3;
+ ctxt->seg_override = VCPU_SREG_DS;
break;
case 0x64: /* FS override */
+ has_seg_override = true;
+ ctxt->seg_override = VCPU_SREG_FS;
+ break;
case 0x65: /* GS override */
has_seg_override = true;
- ctxt->seg_override = ctxt->b & 7;
+ ctxt->seg_override = VCPU_SREG_GS;
break;
case 0x40 ... 0x4f: /* REX */
if (mode != X86EMUL_MODE_PROT64)
so that the segment is never calculated.
Paolo
PATCH v2 11/13 KVM: x86: Protect exit_reason from being used in Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in vmx_handle_exit(). While exit_reason is set by the hardware and therefore should not be attacker-influenced, an unknown exit_reason could potentially be used to perform such an attack.
--- arch/x86/kvm/vmx/vmx.c | 55 +++++++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 25 deletions(-)
arch/x86/kvm/vmx/vmx.c +30 -25
@@ -5918,34 +5918,39 @@ static int vmx_handle_exit(struct kvm_vcpu *vcpu) } } -if (exit_reason < kvm_vmx_max_exit_handlers - && kvm_vmx_exit_handlers[exit_reason]) { +if (exit_reason >= kvm_vmx_max_exit_handlers) + goto unexpected_vmexit;#ifdef CONFIG_RETPOLINE -if (exit_reason ==EXIT_REASON_MSR_WRITE ) -return kvm_emulate_wrmsr (vcpu); -else if (exit_reason ==EXIT_REASON_PREEMPTION_TIMER ) -return handle_preemption_timer (vcpu); -else if (exit_reason ==EXIT_REASON_PENDING_INTERRUPT ) -return handle_interrupt_window (vcpu); -else if (exit_reason ==EXIT_REASON_EXTERNAL_INTERRUPT ) -return handle_external_interrupt (vcpu); -else if (exit_reason ==EXIT_REASON_HLT ) -return kvm_emulate_halt (vcpu); -else if (exit_reason ==EXIT_REASON_EPT_MISCONFIG ) -return handle_ept_misconfig (vcpu); +if (exit_reason ==EXIT_REASON_MSR_WRITE ) +return kvm_emulate_wrmsr (vcpu); +else if (exit_reason ==EXIT_REASON_PREEMPTION_TIMER ) +return handle_preemption_timer (vcpu); +else if (exit_reason ==EXIT_REASON_PENDING_INTERRUPT ) +return handle_interrupt_window (vcpu); +else if (exit_reason ==EXIT_REASON_EXTERNAL_INTERRUPT ) +return handle_external_interrupt (vcpu); +else if (exit_reason ==EXIT_REASON_HLT ) +return kvm_emulate_halt (vcpu); +else if (exit_reason ==EXIT_REASON_EPT_MISCONFIG ) +return handle_ept_misconfig (vcpu);#endif -return kvm_vmx_exit_handlers[exit_reason](vcpu); - }else { -vcpu_unimpl (vcpu,"vmx: unexpected exit reason 0x%x\n" , - exit_reason); -dump_vmcs (); - vcpu->run->exit_reason =KVM_EXIT_INTERNAL_ERROR ; - vcpu->run->internal.suberror = + + exit_reason =array_index_nospec (exit_reason, + kvm_vmx_max_exit_handlers); +if (!kvm_vmx_exit_handlers[exit_reason]) + goto unexpected_vmexit; + +return kvm_vmx_exit_handlers[exit_reason](vcpu); + +unexpected_vmexit: +vcpu_unimpl (vcpu,"vmx: unexpected exit reason 0x%x\n" , exit_reason); +dump_vmcs (); + vcpu->run->exit_reason =KVM_EXIT_INTERNAL_ERROR ; + vcpu->run->internal.suberror =KVM_INTERNAL_ERROR_UNEXPECTED_EXIT_REASON ; - vcpu->run->internal.ndata =1 ; - vcpu->run->internal.data[0 ] = exit_reason; -return 0 ; - } + vcpu->run->internal.ndata =1 ; + vcpu->run->internal.data[0 ] = exit_reason; +return 0 ; }/*
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
PATCH v2 12/13 KVM: x86: Protect DR-based index computations from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes a Spectre-v1/L1TF vulnerability in __kvm_set_dr() and kvm_get_dr().
Both kvm_get_dr() and kvm_set_dr() (a wrapper of __kvm_set_dr()) are exported symbols so KVM should tream them conservatively from a security perspective.
--- arch/x86/kvm/x86.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +6 -2
@@ -1057,9 +1057,11 @@ static u64 kvm_dr6_fixed(struct kvm_vcpu *vcpu)static int __kvm_set_dr (struct kvm_vcpu *vcpu,int dr,unsigned long val) { +size_t size =ARRAY_SIZE (vcpu->arch.db); +switch (dr) { case 0 ... 3: - vcpu->arch.db[dr] = val; + vcpu->arch.db[array_index_nospec (dr, size)] = val;if (!(vcpu->guest_debug &KVM_GUESTDBG_USE_HW_BP )) vcpu->arch.eff_db[dr] = val;break ;
@@ -1096,9 +1098,11 @@ EXPORT_SYMBOL_GPL(kvm_set_dr);int kvm_get_dr (struct kvm_vcpu *vcpu,int dr,unsigned long *val) { +size_t size =ARRAY_SIZE (vcpu->arch.db); +switch (dr) { case 0 ... 3: - *val = vcpu->arch.db[dr]; + *val = vcpu->arch.db[array_index_nospec (dr, size)];break ;case 4 :/* fall through */
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 12/13] KVM: x86: Protect DR-based index computations from Spectre-v1/L1TF attacks
Quoted 7 lines · Marios Pomonis
This fixes a Spectre-v1/L1TF vulnerability in
__kvm_set_dr()andkvm_get_dr().
Bothkvm_get_dr()andkvm_set_dr()(a wrapper of__kvm_set_dr()) are exported symbols so KVM should tream them conservatively from a security perspective.
Quoted 6 lines
Fixes commit 020df0794f57 ("KVM: move DR register access handling into generic code")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
PATCH v2 13/13 KVM: x86: Protect pmu_intel.c from Spectre-v1/L1TF attacks
In reply to Marios PomonisThis fixes Spectre-v1/L1TF vulnerabilities in intel_find_fixed_event() and intel_rdpmc_ecx_to_pmc().kvm_rdpmc() (ancestor of intel_find_fixed_event()) and reprogram_fixed_counter() (ancestor of intel_rdpmc_ecx_to_pmc()) are exported symbols so KVM should treat them conservatively from a security perspective.
--- arch/x86/kvm/vmx/pmu_intel.c | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-)
arch/x86/kvm/vmx/pmu_intel.c +16 -8
@@ -86,10 +86,14 @@ static unsigned intel_find_arch_event(struct kvm_pmu *pmu,static unsigned intel_find_fixed_event (int idx) { -if (idx >=ARRAY_SIZE (fixed_pmc_events)) +u32 event; +size_t size =ARRAY_SIZE (fixed_pmc_events); + +if (idx >= size)return PERF_COUNT_HW_MAX ; -return intel_arch_events[fixed_pmc_events[idx]].event_type; + event = fixed_pmc_events[array_index_nospec (idx, size)]; +return intel_arch_events[event].event_type; }/* check if a PMC is enabled by comparing it with globl_ctrl bits. */
@@ -130,16 +134,20 @@ static struct kvm_pmc *intel_rdpmc_ecx_to_pmc(struct kvm_vcpu *vcpu,struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);bool fixed = idx & (1u <<30 );struct kvm_pmc *counters; +unsigned int num_counters; idx &= ~(3u <<30 ); -if (!fixed && idx >= pmu->nr_arch_gp_counters) -return NULL ; -if (fixed && idx >= pmu->nr_arch_fixed_counters) +if (fixed) { + counters = pmu->fixed_counters; + num_counters = pmu->nr_arch_fixed_counters; + }else { + counters = pmu->gp_counters; + num_counters = pmu->nr_arch_gp_counters; + } +if (idx >= num_counters)return NULL ; - counters = fixed ? pmu->fixed_counters : pmu->gp_counters; *mask &= pmu->counter_bitmask[fixed ?KVM_PMC_FIXED :KVM_PMC_GP ]; - -return &counters[idx]; +return &counters[array_index_nospec (idx, num_counters)]; }static bool intel_is_valid_msr (struct kvm_vcpu *vcpu,u32 msr)
Signature · 1 line
2.24.0.525.g8f36a354ae-goog
Re: [PATCH v2 13/13] KVM: x86: Protect pmu_intel.c from Spectre-v1/L1TF attacks
Quoted 8 lines · Marios Pomonis
This fixes Spectre-v1/L1TF vulnerabilities in
intel_find_fixed_event()andintel_rdpmc_ecx_to_pmc().kvm_rdpmc()(ancestor ofintel_find_fixed_event()) andreprogram_fixed_counter()(ancestor ofintel_rdpmc_ecx_to_pmc()) are exported symbols so KVM should treat them conservatively from a security perspective.
Quoted 6 lines
Fixes commit 25462f7f5295 ("KVM: x86/vPMU: Define kvm_pmu_ops to support vPMU function dispatch")Signed-off-by Nick Finco <[email protected]>Signed-off-by Marios Pomonis <[email protected]>Reviewed-by Andrew Honig <[email protected]>
Quoted 46 lines · Marios Pomonis
From: Nick Finco <[email protected]>
This extends the Spectre-v1 mitigation introduced in
commit75f139aaf896("KVM: x86: Add memory barrier on vmcs field lookup") and commit085331dfc6bb("x86/kvm: Update spectre-v1 mitigation") in light of the Spectre-v1/L1TF combination described here:
https://xenbits.xen.org/xsa/advisory-289.htmlAs reported in the link, an attacker can use the cache-load part of a Spectre-v1 gadget to bring memory into the L1 cache, then use L1TF to leak the loaded memory. Note that this attack is not fully mitigated by core scheduling; firstly when "kvm-intel.vmentry_l1d_flush" is not set to "always", an attacker could use L1TF on the same thread that loaded the memory values in the cache on paths that do not flush the L1 cache on VMEntry. Otherwise, an attacker could perform this attack using a collusion of two sibling hyperthreads: one that loads memory values in the cache during VMExit handling and another that performs L1TF to leak them.
This patch uses
array_index_nospec()to prevent index computations from causing speculative loads into the L1 cache. These cases involve a bounds check followed by a memory read using the index; this is more common than the full Spectre-v1 pattern. In some cases, the index computation can be eliminated entirely by small amounts of refactoring.Marios Pomonis (13):
KVM: x86: Protectx86_decode_insnfrom Spectre-v1/L1TF attacks
KVM: x86: Protect kvm_hv_msr_[get|set]_crash_data() from
Spectre-v1/L1TF attacks
KVM: x86: Refactorpicdev_write()to prevent Spectre-v1/L1TF attacks
KVM: x86: Protectioapic_read_indirect()from Spectre-v1/L1TF attacks
KVM: x86: Protectioapic_write_indirect()from Spectre-v1/L1TF attacks
KVM: x86: Protectkvm_lapic_reg_write()from Spectre-v1/L1TF attacks
KVM: x86: Protect MSR-based index computations infixed_msr_to_seg_unit() KVM: x86: Protect MSR-based index computations in pmu.h KVM: x86: Protect MSR-based index computations from Spectre-v1/L1TF attacks in x86.c KVM: x86: Protect memory accesses from Spectre-v1/L1TF attacks in x86.cKVM: x86: Protect
exit_reasonfrom being used in Spectre-v1/L1TF
attacks
KVM: x86: Protect DR-based index computations from Spectre-v1/L1TF
attacks
KVM: x86: Protectpmu_intel.cfrom Spectre-v1/L1TF attacks
Quoted 12 lines
arch/x86/kvm/emulate.c | 11 ++++-- arch/x86/kvm/hyperv.c | 10 +++-- arch/x86/kvm/i8259.c | 6 ++- arch/x86/kvm/ioapic.c | 15 +++++--- arch/x86/kvm/lapic.c | 13 +++++-- arch/x86/kvm/mtrr.c | 8 +++- arch/x86/kvm/pmu.h | 18 +++++++-- arch/x86/kvm/vmx/pmu_intel.c | 24 ++++++++---- arch/x86/kvm/vmx/vmx.c | 71 +++++++++++++++++++++--------------- arch/x86/kvm/x86.c | 18 +++++++-- 10 files changed, 129 insertions(+), 65 deletions(-)
Queued all except patch 10, thanks.
Paolo