Skip to contentSkip to conversation

KVM: s390: Do not leak kernel stack data in the KVM_S390_INTERRUPT ioctl

PATCH Superseded Thomas Huth 5 participants 15 messages Sep 12, 2019 – Sep 13, 2019

Subsystems (3)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 KVM: s390: Do not leak kernel stack data in the KVM_S390_INTERRUPT ioctl

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +10 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }
Signature · 1 line
2.18.1
#1 lore raw
Quoted 38 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +3 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;

arch/s390/kvm/interrupt.c int s390int_to_s390irq(struct kvm_s390_interrupt *s390int, · line 1975

Quoted 10 lines
arch/s390/kvm/interrupt.c +7 -0
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }

Wouldn't a safe fix be to initialize the struct to zero in the caller?

Signature · 3 lines
Thanks,

David / dhildenb
#2 lore raw
Quoted 43 lines · David Hildenbrand
Quoted 42 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +8 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
Quoted 8 lines

arch/s390/kvm/interrupt.c int s390int_to_s390irq(struct kvm_s390_interrupt *s390int, · line 1975

Quoted 6 lines
arch/s390/kvm/interrupt.c +2 -0
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }

Wouldn't a safe fix be to initialize the struct to zero in the caller?

That's of course possible, too. But that means that we always have to zero out the whole structure, so that's a little bit more of overhead (well, it likely doesn't matter for such a legacy ioctl).

But the more important question: Do we then still care of fixing the PFAULT_INIT interrupt here? Since it requires a parameter, the "case KVM_S390_INT_PFAULT_INIT:" part would be required here anyway.

Thomas

maintainer
#3 lore raw
Quoted 53 lines · Thomas Huth
Quoted 43 lines · David Hildenbrand
Quoted 42 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +8 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
Quoted 8 lines

arch/s390/kvm/interrupt.c int s390int_to_s390irq(struct kvm_s390_interrupt *s390int, · line 1975

Quoted 6 lines
arch/s390/kvm/interrupt.c +2 -0
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }

Wouldn't a safe fix be to initialize the struct to zero in the caller?

Quoted 3 lines

That's of course possible, too. But that means that we always have to zero out the whole structure, so that's a little bit more of overhead (well, it likely doesn't matter for such a legacy ioctl).

Or memset it in s390int_to_s390irq so the caller doesn't need to know. That should be fast enough for such a small struct.

Quoted 4 lines

But the more important question: Do we then still care of fixing the PFAULT_INIT interrupt here? Since it requires a parameter, the "case KVM_S390_INT_PFAULT_INIT:" part would be required here anyway.

Let's wait for Christian's opinion on that.

#4 lore raw
In reply to Thomas Huth
Quoted 53 lines · Thomas Huth
Quoted 43 lines · David Hildenbrand
Quoted 42 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +8 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
Quoted 8 lines

arch/s390/kvm/interrupt.c int s390int_to_s390irq(struct kvm_s390_interrupt *s390int, · line 1975

Quoted 6 lines
arch/s390/kvm/interrupt.c +2 -0
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }

Wouldn't a safe fix be to initialize the struct to zero in the caller?

Quoted 3 lines

That's of course possible, too. But that means that we always have to zero out the whole structure, so that's a little bit more of overhead (well, it likely doesn't matter for such a legacy ioctl).

Yes doing something like

arch/s390/kvm/kvm-s390.c +1 -1
index c19a24e940a1..b1f6f434af5d 100644
@@ -4332,7 +4332,7 @@ long kvm_arch_vcpu_async_ioctl(struct file *filp,
        }
        case KVM_S390_INTERRUPT: {
                struct kvm_s390_interrupt s390int;
-               struct kvm_s390_irq s390irq;
+               struct kvm_s390_irq s390irq = {};
 
                if (copy_from_user(&s390int, argp, sizeof(s390int)))
                        return -EFAULT;

would certainly be ok as well, but

Quoted 3 lines

But the more important question: Do we then still care of fixing the PFAULT_INIT interrupt here? Since it requires a parameter, the "case KVM_S390_INT_PFAULT_INIT:" part would be required here anyway.

as long as we we this interface we should fix it and we should do the pfault thing correctly.
Maybe we should start to deprecate this interface and remove it. For the time being Thomas fix is certainly good enough. We might want to add the designated initializer as an additional safety barrier.

#5 lore raw
Quoted 76 lines · Christian Borntraeger
Quoted 53 lines · Thomas Huth
Quoted 43 lines · David Hildenbrand
Quoted 42 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +8 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
Quoted 8 lines

arch/s390/kvm/interrupt.c int s390int_to_s390irq(struct kvm_s390_interrupt *s390int, · line 1975

Quoted 6 lines
arch/s390/kvm/interrupt.c +2 -0
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }

Wouldn't a safe fix be to initialize the struct to zero in the caller?

Quoted 3 lines

That's of course possible, too. But that means that we always have to zero out the whole structure, so that's a little bit more of overhead (well, it likely doesn't matter for such a legacy ioctl).

Yes doing something like

arch/s390/kvm/kvm-s390.c +1 -1
index c19a24e940a1..b1f6f434af5d 100644
@@ -4332,7 +4332,7 @@ long kvm_arch_vcpu_async_ioctl(struct file *filp,
        }
        case KVM_S390_INTERRUPT: {
                struct kvm_s390_interrupt s390int;
-               struct kvm_s390_irq s390irq;
+               struct kvm_s390_irq s390irq = {};
 
                if (copy_from_user(&s390int, argp, sizeof(s390int)))
                        return -EFAULT;
Quoted 1 line

would certainly be ok as well, but

I don't think that it's urgently necessary, but ok, if you all prefer to have it, too, I can add it to my patch.

Quoted 7 lines
Quoted 3 lines

But the more important question: Do we then still care of fixing the PFAULT_INIT interrupt here? Since it requires a parameter, the "case KVM_S390_INT_PFAULT_INIT:" part would be required here anyway.

as long as we we this interface we should fix it and we should do the pfault thing correctly.
Maybe we should start to deprecate this interface and remove it.

Hmm, we already talked about deprecating support for pre-3.15 kernel stuff in the past (see
https://wiki.qemu.org/ChangeLog/2.12#Future_incompatible_changes for example), since this has been broken in QEMU since quite a while, but the new KVM_S390_IRQ replacement has just been introduced with kernel 4.1 ... so removing this KVM_S390_INTERRUPT ioctl any time soon sounds wrong to me, we might break some userspace programs that are still there in the wild...

Thomas

#7 lore raw
Quoted 10 lines · Cornelia Huck
Quoted 4 lines · On Thu, 12 Sep 2019 13:23:38 +0200 Thomas Huth <[email protected]> wrote:

Hmm, we already talked about deprecating support for pre-3.15 kernel stuff in the past (see
https://wiki.qemu.org/ChangeLog/2.12#Future_incompatible_changes for example),

Btw: did we ever do that? I don't quite recall what code we were talking about...

We never really did - but we also never fixed the issue: If you run the current QEMU on a kernel before 3.15, it refuses to work due to the missing in-kernel FLIC device:

Initialization of device s390-flic-kvm failed: KVM is missing capability KVM_CAP_DEVICE_CTR

Since nobody really complained so far that running QEMU with KVM is still required on a kernel < 3.15, I think we could make this also "official" now and improve the error message a little bit, pointing the user to a kernel >= 3.15.

Thomas

#8 lore raw
Quoted 16 lines · Thomas Huth
Quoted 10 lines · Cornelia Huck
Quoted 4 lines · On Thu, 12 Sep 2019 13:23:38 +0200 Thomas Huth <[email protected]> wrote:

Hmm, we already talked about deprecating support for pre-3.15 kernel stuff in the past (see
https://wiki.qemu.org/ChangeLog/2.12#Future_incompatible_changes for example),

Btw: did we ever do that? I don't quite recall what code we were talking about...

We never really did - but we also never fixed the issue: If you run the current QEMU on a kernel before 3.15, it refuses to work due to the missing in-kernel FLIC device:

Quoted 7 lines

Initialization of device s390-flic-kvm failed: KVM is missing capability KVM_CAP_DEVICE_CTR

Since nobody really complained so far that running QEMU with KVM is still required on a kernel < 3.15, I think we could make this also "official" now and improve the error message a little bit, pointing the user to a kernel >= 3.15.

Didn't we discuss back then to clean up *QEMU* and not the *kernel*? Especially, to wait with cleanups until somebody requests to fix instead. I mean you could have any user space in the wild that still makes use of these interfaces ...

Signature · 3 lines
Thanks,

David / dhildenb
#9 lore raw
Quoted 25 lines · David Hildenbrand
Quoted 16 lines · Thomas Huth
Quoted 10 lines · Cornelia Huck
Quoted 4 lines · On Thu, 12 Sep 2019 13:23:38 +0200 Thomas Huth <[email protected]> wrote:

Hmm, we already talked about deprecating support for pre-3.15 kernel stuff in the past (see
https://wiki.qemu.org/ChangeLog/2.12#Future_incompatible_changes for example),

Btw: did we ever do that? I don't quite recall what code we were talking about...

We never really did - but we also never fixed the issue: If you run the current QEMU on a kernel before 3.15, it refuses to work due to the missing in-kernel FLIC device:

Quoted 7 lines

Initialization of device s390-flic-kvm failed: KVM is missing capability KVM_CAP_DEVICE_CTR

Since nobody really complained so far that running QEMU with KVM is still required on a kernel < 3.15, I think we could make this also "official" now and improve the error message a little bit, pointing the user to a kernel >= 3.15.

Quoted 4 lines

Didn't we discuss back then to clean up *QEMU* and not the *kernel*? Especially, to wait with cleanups until somebody requests to fix instead. I mean you could have any user space in the wild that still makes use of these interfaces ...

Yes, that error message is part of QEMU, so I was referring to that one. Sorry for mixing this into a mail thread on the kernel mailing list :-/

Thomas

#10 lore raw
Quoted 26 lines · Thomas Huth
Quoted 25 lines · David Hildenbrand
Quoted 23 lines · Thomas Huth
Quoted 10 lines · Cornelia Huck
Quoted 4 lines · On Thu, 12 Sep 2019 13:23:38 +0200 Thomas Huth <[email protected]> wrote:

Hmm, we already talked about deprecating support for pre-3.15 kernel stuff in the past (see
https://wiki.qemu.org/ChangeLog/2.12#Future_incompatible_changes for example),

Btw: did we ever do that? I don't quite recall what code we were talking about...

We never really did - but we also never fixed the issue: If you run the current QEMU on a kernel before 3.15, it refuses to work due to the missing in-kernel FLIC device:

Initialization of device s390-flic-kvm failed: KVM is missing capability KVM_CAP_DEVICE_CTR

Since nobody really complained so far that running QEMU with KVM is still required on a kernel < 3.15, I think we could make this also "official" now and improve the error message a little bit, pointing the user to a kernel >= 3.15.

Quoted 7 lines
Quoted 4 lines

Didn't we discuss back then to clean up *QEMU* and not the *kernel*? Especially, to wait with cleanups until somebody requests to fix instead. I mean you could have any user space in the wild that still makes use of these interfaces ...

Yes, that error message is part of QEMU, so I was referring to that one. Sorry for mixing this into a mail thread on the kernel mailing list :-/

Ah okay, I messed up then :)

Signature · 3 lines
Thanks,

David / dhildenb
Reviewed-by
#11 lore raw
In reply to Thomas Huth
Quoted 53 lines · Thomas Huth
Quoted 43 lines · David Hildenbrand
Quoted 42 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +8 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
Quoted 8 lines

arch/s390/kvm/interrupt.c int s390int_to_s390irq(struct kvm_s390_interrupt *s390int, · line 1975

Quoted 6 lines
arch/s390/kvm/interrupt.c +2 -0
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }

Wouldn't a safe fix be to initialize the struct to zero in the caller?

Quoted 3 lines

That's of course possible, too. But that means that we always have to zero out the whole structure, so that's a little bit more of overhead (well, it likely doesn't matter for such a legacy ioctl).

I would vote for doing this as well.

Quoted 5 lines

But the more important question: Do we then still care of fixing the PFAULT_INIT interrupt here? Since it requires a parameter, the "case KVM_S390_INT_PFAULT_INIT:" part would be required here anyway.

That's indeed true.

Quoted 2 lines

Thomas

Signature · 3 lines
Thanks,

David / dhildenb
#12 lore raw
Quoted 54 lines · David Hildenbrand
Quoted 53 lines · Thomas Huth
Quoted 51 lines · David Hildenbrand
Quoted 38 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +3 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;

arch/s390/kvm/interrupt.c int s390int_to_s390irq(struct kvm_s390_interrupt *s390int, · line 1975

Quoted 10 lines
arch/s390/kvm/interrupt.c +7 -0
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }

Wouldn't a safe fix be to initialize the struct to zero in the caller?

Quoted 5 lines
Quoted 3 lines

That's of course possible, too. But that means that we always have to zero out the whole structure, so that's a little bit more of overhead (well, it likely doesn't matter for such a legacy ioctl).

I would vote for doing this as well.

Yes, lets also do the designated initializer, add more text to the patch description (or should we not?) add cc stable and I will pick a v2.

Quoted 15 lines
Quoted 6 lines

But the more important question: Do we then still care of fixing the PFAULT_INIT interrupt here? Since it requires a parameter, the "case KVM_S390_INT_PFAULT_INIT:" part would be required here anyway.

That's indeed true.

Quoted 2 lines

Thomas

Reviewed-by on v1 1/1
#13 lore raw
In reply to Thomas Huth
Quoted 9 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

You mean by using the migration callbacks to get all interrupts back to userspace?

Quoted 5 lines

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Shouldnt we add some more detailed description how this can happen? Something like
"By using the KVM_S390_INTERRUPT ioctl with a KVM_S390_INT_PFAULT_INIT interrupt followed by the KVM_S390_GET_IRQ_STATE ioctl the user can extract a value from the kernel stack."

Quoted 8 lines

Fix it by handling that interrupt type in s390int_to_s390irq(), too. And while we're at it, make sure that s390int_to_s390irq() now directly returns -EINVAL for unknown interrupt types, so that we do not run into this problem again in case we add more interrupt types to do_inject_vcpu() sometime in the future.

Cc stable
Quoted 26 lines
---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
arch/s390/kvm/interrupt.c +10 -0
index 3e7efdd9228a..165dea4c7f19 100644
@@ -1960,6 +1960,16 @@ int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
 	case KVM_S390_MCHK:
 		irq->u.mchk.mcic = s390int->parm64;
 		break;
+	case KVM_S390_INT_PFAULT_INIT:
+		irq->u.ext.ext_params = s390int->parm;
+		irq->u.ext.ext_params2 = s390int->parm64;
+		break;
+	case KVM_S390_RESTART:
+	case KVM_S390_INT_CLOCK_COMP:
+	case KVM_S390_INT_CPU_TIMER:
+		break;
+	default:
+		return -EINVAL;
 	}
 	return 0;
 }
#14 lore raw
Quoted 13 lines · Christian Borntraeger
Quoted 9 lines · Thomas Huth

When the userspace program runs the KVM_S390_INTERRUPT ioctl to inject an interrupt, we convert them from the legacy struct kvm_s390_interrupt to the new struct kvm_s390_irq via the s390int_to_s390irq() function. However, this function does not take care of all types of interrupts that we can inject into the guest later (see do_inject_vcpu()). Since we do not clear out the s390irq values before calling s390int_to_s390irq(), there is a chance that we copy unwanted data from the kernel stack into the guest memory later if the interrupt data has not been properly initialized by s390int_to_s390irq().

Quoted 2 lines

You mean by using the migration callbacks to get all interrupts back to userspace?

Oh, I was not thinking about GET_IRQ_STATE yet, I was thinking about __deliver_pfault_init() which would deliver the value into the guest memory (from where the userspace program could extract it again).

Quoted 10 lines
Quoted 4 lines

Specifically, the problem exists with the KVM_S390_INT_PFAULT_INIT
interrupt: s390int_to_s390irq() does not handle it, but the function __deliver_pfault_init() will later copy the uninitialized stack data from the ext.ext_params2 into the guest memory.

Shouldnt we add some more detailed description how this can happen? Something like
"By using the KVM_S390_INTERRUPT ioctl with a KVM_S390_INT_PFAULT_INIT interrupt followed by the KVM_S390_GET_IRQ_STATE ioctl the user can extract a value from the kernel stack."

GET_IRQ_STATE certainly deserves to be mentioned here, I'll add it to the patch description and will send a v2.

Thomas