Skip to contentSkip to conversation

PCI/MSI: Hardening fixes

PATCH In review Alexander Shishkin 7 participants 16 messages Jan 19, 2023 – Jan 25, 2023

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

cover PCI/MSI: Hardening fixes

Hi,

Here are 2 hardening fixes around MSIX table size/offset handling, aiming to prevent a malicious device or VMM from triggering bugs by supplying bogus values.

Alexander Shishkin (2):
PCI/MSI: Cache the MSIX table size
PCI/MSI: Validate device supplied MSI table offset and size

 drivers/pci/msi/api.c |  7 ++++++-
 drivers/pci/msi/msi.c | 12 +++++++++---
 include/linux/pci.h   |  1 +
 3 files changed, 16 insertions(+), 4 deletions(-)
Signature · 1 line
2.39.0
#1 lore raw

PATCH 1/2 PCI/MSI: Cache the MSIX table size

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
drivers/pci/msi/api.c +6 -1
index b8009aa11f3c..617ea1256487 100644
@@ -75,8 +75,13 @@ int pci_msix_vec_count(struct pci_dev *dev)
 	if (!dev->msix_cap)
 		return -EINVAL;
 
+	if (dev->flags_qsize)
+		return dev->flags_qsize;
+
 	pci_read_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, &control);
-	return msix_table_size(control);
+	dev->flags_qsize = msix_table_size(control);
+
+	return dev->flags_qsize;
 }
 EXPORT_SYMBOL(pci_msix_vec_count);
 
drivers/pci/msi/msi.c +1 -1
index 1f716624ca56..d50cd45119f1 100644
@@ -715,7 +715,7 @@ static int msix_capability_init(struct pci_dev *dev, struct msix_entry *entries,
 
 	pci_read_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, &control);
 	/* Request & Map MSI-X table region */
-	tsize = msix_table_size(control);
+	tsize = pci_msix_vec_count(dev);
 	dev->msix_base = msix_map_region(dev, tsize);
 	if (!dev->msix_base) {
 		ret = -ENOMEM;
include/linux/pci.h +1 -0
index adffd65e84b4..2e1a72a2139d 100644
@@ -352,6 +352,7 @@ struct pci_dev {
 	u8		rom_base_reg;	/* Config register controlling ROM */
 	u8		pin;		/* Interrupt pin this device uses */
 	u16		pcie_flags_reg;	/* Cached PCIe Capabilities Register */
+	u16		flags_qsize;	/* Cached MSIX table size */
 	unsigned long	*dma_alias_mask;/* Mask of enabled devfn aliases */
 
 	struct pci_driver *driver;	/* Driver bound to this device */
Signature · 1 line
2.39.0
#2 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 8 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

Quoted 8 lines
---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.
2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

Thanks

Quoted 48 lines
drivers/pci/msi/api.c +6 -1
index b8009aa11f3c..617ea1256487 100644
@@ -75,8 +75,13 @@ int pci_msix_vec_count(struct pci_dev *dev)
 	if (!dev->msix_cap)
 		return -EINVAL;
 
+	if (dev->flags_qsize)
+		return dev->flags_qsize;
+
 	pci_read_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, &control);
-	return msix_table_size(control);
+	dev->flags_qsize = msix_table_size(control);
+
+	return dev->flags_qsize;
 }
 EXPORT_SYMBOL(pci_msix_vec_count);
 
drivers/pci/msi/msi.c +1 -1
index 1f716624ca56..d50cd45119f1 100644
@@ -715,7 +715,7 @@ static int msix_capability_init(struct pci_dev *dev, struct msix_entry *entries,
 
 	pci_read_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, &control);
 	/* Request & Map MSI-X table region */
-	tsize = msix_table_size(control);
+	tsize = pci_msix_vec_count(dev);
 	dev->msix_base = msix_map_region(dev, tsize);
 	if (!dev->msix_base) {
 		ret = -ENOMEM;
include/linux/pci.h +1 -0
index adffd65e84b4..2e1a72a2139d 100644
@@ -352,6 +352,7 @@ struct pci_dev {
 	u8		rom_base_reg;	/* Config register controlling ROM */
 	u8		pin;		/* Interrupt pin this device uses */
 	u16		pcie_flags_reg;	/* Cached PCIe Capabilities Register */
+	u16		flags_qsize;	/* Cached MSIX table size */
 	unsigned long	*dma_alias_mask;/* Mask of enabled devfn aliases */
 
 	struct pci_driver *driver;	/* Driver bound to this device */
Signature · 1 line
2.39.0
#3 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 19 lines · Leon Romanovsky
Quoted 8 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

Quoted 8 lines
---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 7 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.
2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

Indeed, this was my exact reaction reading this patch. This only makes sure the same (potentially wrong) value is used at all times. So while this results in a consistent use, this doesn't give much guarantee.

The only way to deal with this is to actually handle the resulting fault, similar to what the kernel does when accessing userspace. Not sure how possible this is with something like PCIe.

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
#4 lore raw

RE: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

From: Marc Zyngier

Quoted 31 lines

Sent: 22 January 2023 10:57

Quoted 19 lines · Leon Romanovsky
Quoted 8 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

Quoted 8 lines
---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 7 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.
2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

Quoted 3 lines

Indeed, this was my exact reaction reading this patch. This only makes sure the same (potentially wrong) value is used at all times. So while this results in a consistent use, this doesn't give much guarantee.

Yep, the device can 'choose' to error any PCIe read.

Quoted 3 lines

The only way to deal with this is to actually handle the resulting fault, similar to what the kernel does when accessing userspace. Not sure how possible this is with something like PCIe.

I don't think you get a fault, the PCIe read completes with value ~0. You might get an AER indication, that may not be helpful at all. We've some x86 systems where that ends up as an NMI and panic!

A more valid reason for caching the MSIX table size is to avoid doing a slow PCIe read.
I'm not sure how fast they are on 'normal' hardware, but the Altera fpga we use is particularly pedestrian.
I just measured back-to-back reads at 126 clocks of the internal 125MHz clock so almost exactly 1us - or 3000 clocks of a 3GHz cpu. (I added PCIe trace to the fpga so we can see what goes on.)

There is actually a much more 'interesting' issue with MSIX. There are 16 bytes of data for each interrupt.

The kernel doesn't even try to ensure they are written as a single PCIe TLP, and even if it did there is no real guarantee the writes aren't split before the logic that raises interrupts reads the values.

It is also quite likely that the interrupt raising logic doesn't to an atomic read of all 16 bytes, so a cpu write could split the reads.

This doesn't normally matter - the interrupt is enabled long after the address/data fields are initialised.
But if the interrupt affinity is changed both the address and data fields are likely to be changed on an interrupt that is (nominally) enabled.

It is pretty easy to imagine the new address being used with the old data (or v.v.) or even a 'torn read' of the 64bit address field.

I don't remember seeing anything in the MSIX spec about requirements on the hardware - which puts the onus on the software to ensure the MSIX data is always valid. This means that changing the vector needs to:
Disable the interrupt.
Delay (a read from the MSIX block is probably enough). Update the address and data.
Delay.
Enable the interrupt.
But I don't remember seeing the kernel to any of that.

David.

-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)

#5 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

In reply to Marc Zyngier
Quoted 29 lines · Marc Zyngier
Quoted 19 lines · Leon Romanovsky
Quoted 8 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

Quoted 8 lines
---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 7 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.
2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

Quoted 3 lines

Indeed, this was my exact reaction reading this patch. This only makes sure the same (potentially wrong) value is used at all times. So while this results in a consistent use, this doesn't give much guarantee.

It guarantees that the MSIX table is big enough to fit all the vectors, so it should prevent the page faults from out-of-bounds accesses.

Quoted 3 lines

The only way to deal with this is to actually handle the resulting fault, similar to what the kernel does when accessing userspace. Not sure how possible this is with something like PCIe.

Do you mean replacing MMIO accesses with exception handling accessors? That seems like a monumental effort. And then we'd have to figure out how to handle errors in the __pci_write_msi_msg() path.

Preventing page faults from happening in the first place seems like a more reasonable solution, or what do you think?

Thanks,
--
Alex

maintainer
#6 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

In reply to Leon Romanovsky
Quoted 18 lines · Leon Romanovsky
Quoted 8 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

Quoted 8 lines
---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 3 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

Linux does NOT protect from malicious PCIe devices at this point in time, you are correct. If we wish to change that model, then we can work on that with the explict understanding that most all drivers will need to change as will the bus logic for the busses involved.

To do piece-meal patches like this for no good reason is not a good idea as it achieves nothing in the end :(

thanks,

greg k-h

#7 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 28 lines · On Sun, 22 Jan 2023 11:57:58 +0100 Greg KH <[email protected]> wrote:
Quoted 18 lines · Leon Romanovsky
Quoted 8 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

Quoted 8 lines
---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)  
Quoted 3 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

Linux does NOT protect from malicious PCIe devices at this point in time, you are correct. If we wish to change that model, then we can work on that with the explict understanding that most all drivers will need to change as will the bus logic for the busses involved.

Quoted 6 lines

To do piece-meal patches like this for no good reason is not a good idea as it achieves nothing in the end :(

thanks,

greg k-h

If you care enough about potential malicious PCIe devices, do device attestation and reject any devices that don't support it (which means rejecting pretty much everything today ;).
Or potentially limit what non attested devices are allowed to do.

+CC Lukas who is working on this.

Jonathan

#8 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

In reply to Leon Romanovsky
Quoted 18 lines · Leon Romanovsky
Quoted 8 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

Quoted 8 lines
---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 3 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

This particular bug was preventing our fuzzing from going deeper into the code and reaching some more of the aforementioned gazillion bugs.

Quoted 3 lines

2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

How would that happen? If the device decides to have fewer vectors, they'll all still fit in the ioremapped MSIX table. The worst thing that can happen is 0xffffffff reads from the mmio space, which a device can do anyway. But that shouldn't trigger a page fault or otherwise crash. Or am I missing something?

Thanks,
--
Alex

#9 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 20 lines · Alexander Shishkin
Quoted 18 lines · Leon Romanovsky
Quoted 16 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 6 lines
Quoted 3 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

This particular bug was preventing our fuzzing from going deeper into the code and reaching some more of the aforementioned gazillion bugs.

Your commit message says nothing about fuzzing, but talks about malicious device.
Do you see "gazillion bugs" for devices which don't change their MSI-X table size under the hood, which is main kernel assumption?

If yes, you should fix these bugs.

Quoted 10 lines
Quoted 4 lines

2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

How would that happen? If the device decides to have fewer vectors, they'll all still fit in the ioremapped MSIX table. The worst thing that can happen is 0xffffffff reads from the mmio space, which a device can do anyway. But that shouldn't trigger a page fault or otherwise crash. Or am I missing something?

Like I said, I'm no expert. You should tell me if it safe for all callers of pci_msix_vec_count().

Thanks

Quoted 4 lines

Thanks,
--
Alex

#10 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 7 lines · Leon Romanovsky
Quoted 6 lines · Alexander Shishkin
Quoted 3 lines · Leon Romanovsky

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

Quoted 5 lines
Quoted 2 lines

This particular bug was preventing our fuzzing from going deeper into the code and reaching some more of the aforementioned gazillion bugs.

Your commit message says nothing about fuzzing, but talks about malicious device.

A malicious device is what the fuzzing is aiming to simulate. The fact of fuzzing process itself didn't seem relevant to the patch, so I didn't include it, going instead for the problem statement and proposed solution. Will the commit message benefit from mentioning fuzzing?

Quoted 2 lines

Do you see "gazillion bugs" for devices which don't change their MSI-X table size under the hood, which is main kernel assumption?

Not so far.

Quoted 1 line

If yes, you should fix these bugs.

That's absolutely the intention.

Quoted 4 lines
Quoted 4 lines
Quoted 3 lines

2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

Quoted 8 lines
Quoted 5 lines

How would that happen? If the device decides to have fewer vectors, they'll all still fit in the ioremapped MSIX table. The worst thing that can happen is 0xffffffff reads from the mmio space, which a device can do anyway. But that shouldn't trigger a page fault or otherwise crash. Or am I missing something?

Like I said, I'm no expert. You should tell me if it safe for all callers of pci_msix_vec_count().

Well, since you stated that the reverse will cause a kernel crash, I had to ask how. I'll include some version of the above paragraph in the commit message to indicate that we reverse situation has been considered.

Regards,
--
Alex

#11 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 12 lines · Alexander Shishkin
Quoted 10 lines · Leon Romanovsky
Quoted 8 lines · Alexander Shishkin
Quoted 3 lines · Leon Romanovsky

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

This particular bug was preventing our fuzzing from going deeper into the code and reaching some more of the aforementioned gazillion bugs.

Quoted 7 lines
Quoted 2 lines

Your commit message says nothing about fuzzing, but talks about malicious device.

A malicious device is what the fuzzing is aiming to simulate. The fact of fuzzing process itself didn't seem relevant to the patch, so I didn't include it, going instead for the problem statement and proposed solution. Will the commit message benefit from mentioning fuzzing?

No, for most if not all kernel developers, the fuzzing means some sort of random user-space input. PCI devices are trusted in the kernel.

Quoted 5 lines
Quoted 3 lines

Do you see "gazillion bugs" for devices which don't change their MSI-X table size under the hood, which is main kernel assumption?

Not so far.

So please share them with us.

Quoted 4 lines
Quoted 2 lines

If yes, you should fix these bugs.

That's absolutely the intention.

So let's fix the bugs and not hide them.

Quoted 11 lines
Quoted 11 lines
Quoted 10 lines
Quoted 4 lines

2. Device can report large table size, kernel will cache it and malicious device will reduce it back. It is not handled and will cause to kernel crash too.

How would that happen? If the device decides to have fewer vectors, they'll all still fit in the ioremapped MSIX table. The worst thing that can happen is 0xffffffff reads from the mmio space, which a device can do anyway. But that shouldn't trigger a page fault or otherwise crash. Or am I missing something?

Quoted 6 lines
Quoted 2 lines

Like I said, I'm no expert. You should tell me if it safe for all callers of pci_msix_vec_count().

Well, since you stated that the reverse will cause a kernel crash, I had to ask how. I'll include some version of the above paragraph in the commit message to indicate that we reverse situation has been considered.

Not really. I didn't see any explanation how will it work if number of vectors (which MSI-X table represents) is completely different from seeing by PCI core.

Thanks

Quoted 4 lines

Regards,
--
Alex

#12 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 10 lines · Leon Romanovsky
Quoted 6 lines · Alexander Shishkin

Leon Romanovsky <[email protected]> writes:

A malicious device is what the fuzzing is aiming to simulate. The fact of fuzzing process itself didn't seem relevant to the patch, so I didn't include it, going instead for the problem statement and proposed solution. Will the commit message benefit from mentioning fuzzing?

No, for most if not all kernel developers, the fuzzing means some sort of random user-space input. PCI devices are trusted in the kernel.

Right, it's a different kind of fuzzing. Apologies, I should have made it clear.

Quoted 6 lines
Quoted 4 lines
Quoted 2 lines

Do you see "gazillion bugs" for devices which don't change their MSI-X table size under the hood, which is main kernel assumption?

Not so far.

So please share them with us.

We do, as soon as we find them. This patch is one such instance.

Quoted 5 lines
Quoted 3 lines
Quoted 1 line

If yes, you should fix these bugs.

That's absolutely the intention.

So let's fix the bugs and not hide them.

Yes, that's what this patch aims to achieve.

Thanks,
--
Alex

maintainer
#13 lore raw

Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

In reply to Alexander Shishkin
Quoted 20 lines · Alexander Shishkin
Quoted 18 lines · Leon Romanovsky
Quoted 16 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 6 lines
Quoted 3 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

This particular bug was preventing our fuzzing from going deeper into the code and reaching some more of the aforementioned gazillion bugs.

As per our documentation, if you are "fixing" things based on a tool you have, you HAVE TO document that in the changelog. Otherwise we just get to reject the patch flat out (hint, this has caused more than one group of developers to just be flat out banned for ignoring...)

And what kind of tool is now fuzzing PCI config accesses with "malicious" devices? Again, this is NOT something that Linux currently even attempts to want to protect itself against. If you are wanting to change that model, wonderful, let's discuss that and work on defining the scope of your new security threat model and go from there. Don't throw random patches at us and expect us to think they are even valid.

Again, Linux trusts PCI devices. If you don't want to trust PCI devices, we already have a framework in place to prevent that which is independant of this area of the PCI code. Use that, or let's discuss why that is insufficient.

Note, this is NOT the first time I have told developers from Intel about this. Why you all keep ignoring this is beyond me, I think you keep thinking that if you don't send patches through me, you can just ignore my statements about this. Odd...

greg k-h

#14 lore raw

RE: [PATCH 1/2] PCI/MSI: Cache the MSIX table size

Quoted 41 lines · Alexander Shishkin
Quoted 20 lines
Quoted 18 lines · Leon Romanovsky
Quoted 16 lines · Alexander Shishkin

A malicious device can change its MSIX table size between the table ioremap() and subsequent accesses, resulting in a kernel page fault in pci_write_msg_msix().

To avoid this, cache the table size observed at the moment of table ioremap() and use the cached value. This, however, does not help drivers that peek at the PCIE_MSIX_FLAGS register directly.

---
 drivers/pci/msi/api.c | 7 ++++++-
 drivers/pci/msi/msi.c | 2 +-
 include/linux/pci.h   | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
Quoted 6 lines
Quoted 3 lines

I'm not security expert here, but not sure that this protects from anything.
1. Kernel relies on working and not-malicious HW. There are gazillion ways to cause crashes other than changing MSI-X.

This particular bug was preventing our fuzzing from going deeper into the code and reaching some more of the aforementioned gazillion bugs.

As per our documentation, if you are "fixing" things based on a tool you have, you HAVE TO document that in the changelog. Otherwise we just get to reject the patch flat out (hint, this has caused more than one group of developers to just be flat out banned for ignoring...)

And what kind of tool is now fuzzing PCI config accesses with "malicious" devices? Again, this is NOT something that Linux currently even attempts to want to protect itself against. If you are wanting to change that model, wonderful, let's discuss that and work on defining the scope of your new security threat model and go from there. Don't throw random patches at us and expect us to think they are even valid.

Quoted 4 lines

Again, Linux trusts PCI devices. If you don't want to trust PCI devices, we already have a framework in place to prevent that which is independant of this area of the PCI code. Use that, or let's discuss why that is insufficient.

Sure, I have started a new thread on this in
https://lore.kernel.org/all/DM8PR11MB57505481B2FE79C3D56C9201E7CE9@DM8PR11MB5750.namprd11.prod.outlook.com/

I think it is much bigger topic to discuss, so better be handled separately.

Best Regards,
Elena.

#15 lore raw

PATCH 2/2 PCI/MSI: Validate device supplied MSI table offset and size

In reply to Alexander Shishkin

Currently, the MSI table offset supplied by device's config space is passed directly into ioremap() without validation, allowing, for example, a malicious VMM to trick the OS into exposing its private memory.

Correct this by making sure the table with the given number of vectors fits into its BIR starting at the provided table offset.

---
 drivers/pci/msi/msi.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/pci/msi/msi.c +8 -2
index d50cd45119f1..e93e633cb6a3 100644
@@ -552,7 +552,8 @@ static void __iomem *msix_map_region(struct pci_dev *dev,
 				     unsigned int nr_entries)
 {
 	resource_size_t phys_addr;
-	u32 table_offset;
+	u32 table_offset, table_size;
+	resource_size_t bir_size;
 	unsigned long flags;
 	u8 bir;
 
@@ -563,10 +564,15 @@ static void __iomem *msix_map_region(struct pci_dev *dev,
 	if (!flags || (flags & IORESOURCE_UNSET))
 		return NULL;
 
+	bir_size = pci_resource_len(dev, bir);
+	table_size = nr_entries * PCI_MSIX_ENTRY_SIZE;
 	table_offset &= PCI_MSIX_TABLE_OFFSET;
+	if (bir_size < table_size || table_offset > bir_size - table_size)
+		return NULL;
+
 	phys_addr = pci_resource_start(dev, bir) + table_offset;
 
-	return ioremap(phys_addr, nr_entries * PCI_MSIX_ENTRY_SIZE);
+	return ioremap(phys_addr, table_size);
 }
 
 /**
Signature · 1 line
2.39.0