PCI/MSI: Hardening fixes
Subsystems (2)
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
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
@@ -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
@@ -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
@@ -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
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 inpci_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 thePCIE_MSIX_FLAGSregister directly.
Quoted 8 lines
Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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@@ -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@@ -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@@ -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
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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Quoted 8 lines
Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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.
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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Quoted 8 lines
Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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)
Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size
In reply to Marc ZyngierQuoted 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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Quoted 8 lines
Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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
Greg KH
maintainerRe: [PATCH 1/2] PCI/MSI: Cache the MSIX table size
In reply to Leon RomanovskyQuoted 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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Quoted 8 lines
Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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
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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Quoted 8 lines
Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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
Re: [PATCH 1/2] PCI/MSI: Cache the MSIX table size
In reply to Leon RomanovskyQuoted 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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Quoted 8 lines
Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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
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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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
0xffffffffreads 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
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
0xffffffffreads 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
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
0xffffffffreads 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
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
Greg KH
maintainerRe: [PATCH 1/2] PCI/MSI: Cache the MSIX table size
In reply to Alexander ShishkinQuoted 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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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
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 inpci_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 thePCIE_MSIX_FLAGSregister directly.Signed-off-by Alexander Shishkin <[email protected]>Reviewed-by Mika Westerberg <[email protected]>--- 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.
PATCH 2/2 PCI/MSI: Validate device supplied MSI table offset and size
In reply to Alexander ShishkinCurrently, 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
@@ -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